commit c08fa921cdd06232673c84270c4ae15461e592d2 · zbrox.com/jacquard

+103 -15

Cargo.lock

···

       1761
       1761
        
        "bytes",

     

       1762
       1762
        
        "clap",

     

       1763
       1763
        
        "http",

     

       1764
       1764
       -
        "jacquard-api",

     

       1765
       1765
       -
        "jacquard-common",

     

       1766
       1766
       -
        "jacquard-derive",

     

       1767
       1767
       -
        "jacquard-identity",

     

       1764
       1764
       +
        "jacquard-api 0.4.1",

     

       1765
       1765
       +
        "jacquard-common 0.4.0",

     

       1766
       1766
       +
        "jacquard-derive 0.4.0",

     

       1767
       1767
       +
        "jacquard-identity 0.4.0",

     

       1768
       1768
        
        "jacquard-oauth",

     

       1769
       1769
        
        "jose-jwk",

     

       1770
       1770
        
        "miette",

     
···

       1786
       1786
        
       [[package]]

     

       1787
       1787
        
       name = "jacquard-api"

     

       1788
       1788
        
       version = "0.4.0"

     

       1789
       1789
       +
       source = "git+https://tangled.org/@nonbinary.computer/jacquard#0cbdaf71e0721122b354892bb8ae49aa3ffcc9bc"

     

       1789
       1790
        
       dependencies = [

     

       1790
       1791
        
        "bon",

     

       1791
       1792
        
        "bytes",

     

       1792
       1792
       -
        "jacquard-common",

     

       1793
       1793
       -
        "jacquard-derive",

     

       1793
       1793
       +
        "jacquard-common 0.4.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",

     

       1794
       1794
       +
        "jacquard-derive 0.4.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",

     

       1795
       1795
       +
        "miette",

     

       1796
       1796
       +
        "serde",

     

       1797
       1797
       +
        "thiserror 2.0.17",

     

       1798
       1798
       +
       ]

     

       1799
       1799
       +
       

     

       1800
       1800
       +
       [[package]]

     

       1801
       1801
       +
       name = "jacquard-api"

     

       1802
       1802
       +
       version = "0.4.1"

     

       1803
       1803
       +
       dependencies = [

     

       1804
       1804
       +
        "bon",

     

       1805
       1805
       +
        "bytes",

     

       1806
       1806
       +
        "jacquard-common 0.4.0",

     

       1807
       1807
       +
        "jacquard-derive 0.4.0",

     

       1794
       1808
        
        "miette",

     

       1795
       1809
        
        "serde",

     

       1796
       1810
        
        "thiserror 2.0.17",

     
···

       1805
       1819
        
        "axum-test",

     

       1806
       1820
        
        "bytes",

     

       1807
       1821
        
        "jacquard",

     

       1808
       1808
       -
        "jacquard-common",

     

       1822
       1822
       +
        "jacquard-common 0.4.0",

     

       1809
       1823
        
        "miette",

     

       1810
       1824
        
        "serde",

     

       1811
       1825
        
        "serde_html_form",

     
···

       1856
       1870
        
       ]

     

       1857
       1871
        
       

     

       1858
       1872
        
       [[package]]

     

       1873
       1873
       +
       name = "jacquard-common"

     

       1874
       1874
       +
       version = "0.4.0"

     

       1875
       1875
       +
       source = "git+https://tangled.org/@nonbinary.computer/jacquard#0cbdaf71e0721122b354892bb8ae49aa3ffcc9bc"

     

       1876
       1876
       +
       dependencies = [

     

       1877
       1877
       +
        "async-trait",

     

       1878
       1878
       +
        "base64 0.22.1",

     

       1879
       1879
       +
        "bon",

     

       1880
       1880
       +
        "bytes",

     

       1881
       1881
       +
        "chrono",

     

       1882
       1882
       +
        "cid",

     

       1883
       1883
       +
        "http",

     

       1884
       1884
       +
        "ipld-core",

     

       1885
       1885
       +
        "langtag",

     

       1886
       1886
       +
        "miette",

     

       1887
       1887
       +
        "multibase",

     

       1888
       1888
       +
        "multihash",

     

       1889
       1889
       +
        "num-traits",

     

       1890
       1890
       +
        "ouroboros",

     

       1891
       1891
       +
        "rand 0.9.2",

     

       1892
       1892
       +
        "regex",

     

       1893
       1893
       +
        "reqwest",

     

       1894
       1894
       +
        "serde",

     

       1895
       1895
       +
        "serde_html_form",

     

       1896
       1896
       +
        "serde_ipld_dagcbor",

     

       1897
       1897
       +
        "serde_json",

     

       1898
       1898
       +
        "serde_with",

     

       1899
       1899
       +
        "smol_str",

     

       1900
       1900
       +
        "thiserror 2.0.17",

     

       1901
       1901
       +
        "tokio",

     

       1902
       1902
       +
        "trait-variant",

     

       1903
       1903
       +
        "url",

     

       1904
       1904
       +
       ]

     

       1905
       1905
       +
       

     

       1906
       1906
       +
       [[package]]

     

       1859
       1907
        
       name = "jacquard-derive"

     

       1860
       1908
        
       version = "0.4.0"

     

       1861
       1909
        
       dependencies = [

     

       1862
       1910
        
        "heck 0.5.0",

     

       1863
       1911
        
        "itertools",

     

       1864
       1864
       -
        "jacquard-common",

     

       1912
       1912
       +
        "jacquard-common 0.4.0",

     

       1913
       1913
       +
        "prettyplease",

     

       1914
       1914
       +
        "proc-macro2",

     

       1915
       1915
       +
        "quote",

     

       1916
       1916
       +
        "serde",

     

       1917
       1917
       +
        "serde_json",

     

       1918
       1918
       +
        "serde_repr",

     

       1919
       1919
       +
        "serde_with",

     

       1920
       1920
       +
        "syn 2.0.106",

     

       1921
       1921
       +
       ]

     

       1922
       1922
       +
       

     

       1923
       1923
       +
       [[package]]

     

       1924
       1924
       +
       name = "jacquard-derive"

     

       1925
       1925
       +
       version = "0.4.0"

     

       1926
       1926
       +
       source = "git+https://tangled.org/@nonbinary.computer/jacquard#0cbdaf71e0721122b354892bb8ae49aa3ffcc9bc"

     

       1927
       1927
       +
       dependencies = [

     

       1928
       1928
       +
        "heck 0.5.0",

     

       1929
       1929
       +
        "itertools",

     

       1865
       1930
        
        "prettyplease",

     

       1866
       1931
        
        "proc-macro2",

     

       1867
       1932
        
        "quote",

     
···

       1881
       1946
        
        "bytes",

     

       1882
       1947
        
        "hickory-resolver",

     

       1883
       1948
        
        "http",

     

       1884
       1884
       -
        "jacquard-api",

     

       1885
       1885
       -
        "jacquard-common",

     

       1949
       1949
       +
        "jacquard-api 0.4.1",

     

       1950
       1950
       +
        "jacquard-common 0.4.0",

     

       1951
       1951
       +
        "miette",

     

       1952
       1952
       +
        "percent-encoding",

     

       1953
       1953
       +
        "reqwest",

     

       1954
       1954
       +
        "serde",

     

       1955
       1955
       +
        "serde_html_form",

     

       1956
       1956
       +
        "serde_json",

     

       1957
       1957
       +
        "thiserror 2.0.17",

     

       1958
       1958
       +
        "tokio",

     

       1959
       1959
       +
        "url",

     

       1960
       1960
       +
        "urlencoding",

     

       1961
       1961
       +
       ]

     

       1962
       1962
       +
       

     

       1963
       1963
       +
       [[package]]

     

       1964
       1964
       +
       name = "jacquard-identity"

     

       1965
       1965
       +
       version = "0.4.0"

     

       1966
       1966
       +
       source = "git+https://tangled.org/@nonbinary.computer/jacquard#0cbdaf71e0721122b354892bb8ae49aa3ffcc9bc"

     

       1967
       1967
       +
       dependencies = [

     

       1968
       1968
       +
        "async-trait",

     

       1969
       1969
       +
        "bon",

     

       1970
       1970
       +
        "bytes",

     

       1971
       1971
       +
        "http",

     

       1972
       1972
       +
        "jacquard-api 0.4.0",

     

       1973
       1973
       +
        "jacquard-common 0.4.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",

     

       1886
       1974
        
        "miette",

     

       1887
       1975
        
        "percent-encoding",

     

       1888
       1976
        
        "reqwest",

     
···

       1904
       1992
        
        "glob",

     

       1905
       1993
        
        "heck 0.5.0",

     

       1906
       1994
        
        "itertools",

     

       1907
       1907
       -
        "jacquard-api",

     

       1908
       1908
       -
        "jacquard-common",

     

       1909
       1909
       -
        "jacquard-identity",

     

       1995
       1995
       +
        "jacquard-api 0.4.0",

     

       1996
       1996
       +
        "jacquard-common 0.4.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",

     

       1997
       1997
       +
        "jacquard-identity 0.4.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",

     

       1910
       1998
        
        "kdl",

     

       1911
       1999
        
        "miette",

     

       1912
       2000
        
        "prettyplease",

     
···

       1935
       2023
        
        "dashmap",

     

       1936
       2024
        
        "elliptic-curve",

     

       1937
       2025
        
        "http",

     

       1938
       1938
       -
        "jacquard-common",

     

       1939
       1939
       -
        "jacquard-identity",

     

       2026
       2026
       +
        "jacquard-common 0.4.0",

     

       2027
       2027
       +
        "jacquard-identity 0.4.0",

     

       1940
       2028
        
        "jose-jwa",

     

       1941
       2029
        
        "jose-jwk",

     

       1942
       2030
        
        "miette",

+7 -6

crates/jacquard-api/Cargo.toml

···

       2
       2
        
       name = "jacquard-api"

     

       3
       3
        
       description = "Generated AT Protocol API bindings for Jacquard"

     

       4
       4
        
       edition.workspace = true

     

       5
       5
       -
       version = "0.4.0"

     

       5
       5
       +
       version = "0.4.1"

     

       6
       6
        
       authors.workspace = true

     

       7
       7
        
       repository.workspace = true

     

       8
       8
        
       keywords.workspace = true

     
···

       35
       35
        
       # --- generated ---

     

       36
       36
        
       # Generated namespace features

     

       37
       37
        
       app_blebbit = []

     

       38
       38
       -
       app_bsky = ["com_atproto"]

     

       38
       38
       +
       app_bsky = []

     

       39
       39
        
       app_ocho = []

     

       40
       40
        
       beauty_cybernetic = []

     

       41
       41
        
       blog_pckt = []

     
···

       44
       44
        
       blue_linkat = []

     

       45
       45
        
       blue_zio = []

     

       46
       46
        
       buzz_bookhive = []

     

       47
       47
       -
       chat_bsky = ["app_bsky"]

     

       47
       47
       +
       chat_bsky = []

     

       48
       48
        
       club_stellz = []

     

       49
       49
        
       com_atproto = []

     

       50
       50
        
       com_bad_example = []

     
···

       56
       56
        
       dev_fudgeu = []

     

       57
       57
        
       dev_ocbwoy3 = []

     

       58
       58
        
       dev_regnault = []

     

       59
       59
       +
       events_smokesignal = []

     

       59
       60
        
       fyi_unravel = []

     

       60
       61
        
       garden_lexicon = []

     

       61
       62
        
       moe_karashiiro = []

     

       62
       63
        
       my_skylights = []

     

       63
       64
        
       net_aftertheinter = []

     

       64
       64
       -
       net_anisota = ["app_bsky", "com_atproto"]

     

       65
       65
       +
       net_anisota = ["app_bsky"]

     

       65
       66
        
       net_bnewbold = []

     

       66
       67
        
       net_mmatt = []

     

       67
       68
        
       network_slices = []

     

       68
       69
        
       org_devcon = []

     

       69
       70
        
       org_robocracy = []

     

       70
       71
        
       place_atwork = []

     

       71
       71
       -
       place_stream = []

     

       72
       72
       +
       place_stream = ["app_bsky"]

     

       72
       73
        
       pub_leaflet = []

     

       73
       74
        
       sh_tangled = []

     

       74
       75
        
       sh_weaver = ["app_bsky"]

     

       75
       76
        
       social_clippr = []

     

       76
       76
       -
       social_grain = ["com_atproto"]

     

       77
       77
       +
       social_grain = []

     

       77
       78
        
       social_pmsky = []

     

       78
       79
        
       social_psky = []

     

       79
       80
        
       tools_ozone = ["chat_bsky", "com_atproto"]

+26

crates/jacquard-api/lexicons/win_tomo-x_pushat_allow.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "win.tomo-x.pushat.allow",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "record",

     

       7
       7
       +
             "description": "allow service to push. key must be did",

     

       8
       8
       +
             "key": "any",

     

       9
       9
       +
             "record": {

     

       10
       10
       +
               "type": "object",

     

       11
       11
       +
               "required": [

     

       12
       12
       +
                 "createdAt"

     

       13
       13
       +
               ],

     

       14
       14
       +
               "properties": {

     

       15
       15
       +
                 "config": {

     

       16
       16
       +
                   "type": "unknown"

     

       17
       17
       +
                 },

     

       18
       18
       +
                 "createdAt": {

     

       19
       19
       +
                   "type": "string",

     

       20
       20
       +
                   "format": "datetime"

     

       21
       21
       +
                 }

     

       22
       22
       +
               }

     

       23
       23
       +
             }

     

       24
       24
       +
           }

     

       25
       25
       +
         }

     

       26
       26
       +
       }

+63

crates/jacquard-api/lexicons/win_tomo-x_pushat_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "win.tomo-x.pushat.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "deviceList": {

     

       6
       6
       +
             "type": "array",

     

       7
       7
       +
             "items": {

     

       8
       8
       +
               "type": "ref",

     

       9
       9
       +
               "ref": "#deviceListItem"

     

       10
       10
       +
             }

     

       11
       11
       +
           },

     

       12
       12
       +
           "deviceListItem": {

     

       13
       13
       +
             "type": "object",

     

       14
       14
       +
             "required": [

     

       15
       15
       +
               "name",

     

       16
       16
       +
               "id",

     

       17
       17
       +
               "current"

     

       18
       18
       +
             ],

     

       19
       19
       +
             "properties": {

     

       20
       20
       +
               "current": {

     

       21
       21
       +
                 "type": "boolean",

     

       22
       22
       +
                 "default": false

     

       23
       23
       +
               },

     

       24
       24
       +
               "id": {

     

       25
       25
       +
                 "type": "string",

     

       26
       26
       +
                 "format": "tid"

     

       27
       27
       +
               },

     

       28
       28
       +
               "name": {

     

       29
       29
       +
                 "type": "string",

     

       30
       30
       +
                 "maxLength": 300,

     

       31
       31
       +
                 "maxGraphemes": 30

     

       32
       32
       +
               }

     

       33
       33
       +
             }

     

       34
       34
       +
           },

     

       35
       35
       +
           "notifyBody": {

     

       36
       36
       +
             "type": "object",

     

       37
       37
       +
             "required": [

     

       38
       38
       +
               "title",

     

       39
       39
       +
               "body"

     

       40
       40
       +
             ],

     

       41
       41
       +
             "properties": {

     

       42
       42
       +
               "body": {

     

       43
       43
       +
                 "type": "string",

     

       44
       44
       +
                 "description": "Body text of the notification."

     

       45
       45
       +
               },

     

       46
       46
       +
               "icon": {

     

       47
       47
       +
                 "type": "string",

     

       48
       48
       +
                 "description": "The URI of the icon displayed in the notification.",

     

       49
       49
       +
                 "format": "uri"

     

       50
       50
       +
               },

     

       51
       51
       +
               "link": {

     

       52
       52
       +
                 "type": "string",

     

       53
       53
       +
                 "description": "Experimental — do not use. The URI to open when the notification is clicked.",

     

       54
       54
       +
                 "format": "uri"

     

       55
       55
       +
               },

     

       56
       56
       +
               "title": {

     

       57
       57
       +
                 "type": "string",

     

       58
       58
       +
                 "description": "Title text of the notification."

     

       59
       59
       +
               }

     

       60
       60
       +
             }

     

       61
       61
       +
           }

     

       62
       62
       +
         }

     

       63
       63
       +
       }

+10 -1

crates/jacquard-api/lexicons/win_tomo-x_pushat_pushNotify.json

···

       19
       19
        
                   },

     

       20
       20
        
                   "target": {

     

       21
       21
        
                     "type": "string",

     

       22
       22
       +
                     "description": "The DID of the target user to whom the notification will be sent.",

     

       22
       23
        
                     "format": "did"

     

       23
       24
        
                   }

     

       24
       25
        
                 }

     
···

       30
       31
        
                 "type": "object",

     

       31
       32
        
                 "properties": {}

     

       32
       33
        
               }

     

       33
       33
       -
             }

     

       34
       34
       +
             },

     

       35
       35
       +
             "errors": [

     

       36
       36
       +
               {

     

       37
       37
       +
                 "name": "ServiceNotAllowedError"

     

       38
       38
       +
               },

     

       39
       39
       +
               {

     

       40
       40
       +
                 "name": "DeviceNotFoundError"

     

       41
       41
       +
               }

     

       42
       42
       +
             ]

     

       34
       43
        
           }

     

       35
       44
        
         }

     

       36
       45
        
       }

+72 -21

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

···

       396
       396
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       397
       397
        
           #[serde(borrow)]

     

       398
       398
        
           pub postgate_embedding_rules: std::option::Option<

     

       399
       399
       -
               Vec<jacquard_common::types::value::Data<'a>>,

     

       399
       399
       +
               Vec<crate::app_bsky::feed::postgate::DisableRule<'a>>,

     

       400
       400
        
           >,

     

       401
       401
        
           ///Matches threadgate record. List of rules defining who can reply to this users posts. If value is an empty array, no one can reply. If value is undefined, anyone can reply.

     

       402
       402
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       403
       403
        
           #[serde(borrow)]

     

       404
       404
        
           pub threadgate_allow_rules: std::option::Option<

     

       405
       405
       -
               Vec<jacquard_common::types::value::Data<'a>>,

     

       405
       405
       +
               Vec<PostInteractionSettingsPrefThreadgateAllowRulesItem<'a>>,

     

       406
       406
        
           >,

     

       407
       407
        
       }

     

       408
       408
        
       

     

       409
       409
       -
       pub type Preferences<'a> = Vec<jacquard_common::types::value::Data<'a>>;

     

       409
       409
       +
       #[jacquard_derive::open_union]

     

       410
       410
       +
       #[derive(

     

       411
       411
       +
           serde::Serialize,

     

       412
       412
       +
           serde::Deserialize,

     

       413
       413
       +
           Debug,

     

       414
       414
       +
           Clone,

     

       415
       415
       +
           PartialEq,

     

       416
       416
       +
           Eq,

     

       417
       417
       +
           jacquard_derive::IntoStatic

     

       418
       418
       +
       )]

     

       419
       419
       +
       #[serde(tag = "$type")]

     

       420
       420
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       421
       421
       +
       pub enum PostInteractionSettingsPrefThreadgateAllowRulesItem<'a> {

     

       422
       422
       +
           #[serde(rename = "app.bsky.feed.threadgate#mentionRule")]

     

       423
       423
       +
           ThreadgateMentionRule(Box<crate::app_bsky::feed::threadgate::MentionRule<'a>>),

     

       424
       424
       +
           #[serde(rename = "app.bsky.feed.threadgate#followerRule")]

     

       425
       425
       +
           ThreadgateFollowerRule(Box<crate::app_bsky::feed::threadgate::FollowerRule<'a>>),

     

       426
       426
       +
           #[serde(rename = "app.bsky.feed.threadgate#followingRule")]

     

       427
       427
       +
           ThreadgateFollowingRule(Box<crate::app_bsky::feed::threadgate::FollowingRule<'a>>),

     

       428
       428
       +
           #[serde(rename = "app.bsky.feed.threadgate#listRule")]

     

       429
       429
       +
           ThreadgateListRule(Box<crate::app_bsky::feed::threadgate::ListRule<'a>>),

     

       430
       430
       +
       }

     

       431
       431
       +
       

     

       432
       432
       +
       #[jacquard_derive::open_union]

     

       433
       433
       +
       #[derive(

     

       434
       434
       +
           serde::Serialize,

     

       435
       435
       +
           serde::Deserialize,

     

       436
       436
       +
           Debug,

     

       437
       437
       +
           Clone,

     

       438
       438
       +
           PartialEq,

     

       439
       439
       +
           Eq,

     

       440
       440
       +
           jacquard_derive::IntoStatic

     

       441
       441
       +
       )]

     

       442
       442
       +
       #[serde(tag = "$type")]

     

       443
       443
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       444
       444
       +
       pub enum PreferencesItem<'a> {

     

       445
       445
       +
           #[serde(rename = "app.bsky.actor.defs#adultContentPref")]

     

       446
       446
       +
           AdultContentPref(Box<crate::app_bsky::actor::AdultContentPref<'a>>),

     

       447
       447
       +
           #[serde(rename = "app.bsky.actor.defs#contentLabelPref")]

     

       448
       448
       +
           ContentLabelPref(Box<crate::app_bsky::actor::ContentLabelPref<'a>>),

     

       449
       449
       +
           #[serde(rename = "app.bsky.actor.defs#savedFeedsPref")]

     

       450
       450
       +
           SavedFeedsPref(Box<crate::app_bsky::actor::SavedFeedsPref<'a>>),

     

       451
       451
       +
           #[serde(rename = "app.bsky.actor.defs#savedFeedsPrefV2")]

     

       452
       452
       +
           SavedFeedsPrefV2(Box<crate::app_bsky::actor::SavedFeedsPrefV2<'a>>),

     

       453
       453
       +
           #[serde(rename = "app.bsky.actor.defs#personalDetailsPref")]

     

       454
       454
       +
           PersonalDetailsPref(Box<crate::app_bsky::actor::PersonalDetailsPref<'a>>),

     

       455
       455
       +
           #[serde(rename = "app.bsky.actor.defs#feedViewPref")]

     

       456
       456
       +
           FeedViewPref(Box<crate::app_bsky::actor::FeedViewPref<'a>>),

     

       457
       457
       +
           #[serde(rename = "app.bsky.actor.defs#threadViewPref")]

     

       458
       458
       +
           ThreadViewPref(Box<crate::app_bsky::actor::ThreadViewPref<'a>>),

     

       459
       459
       +
           #[serde(rename = "app.bsky.actor.defs#interestsPref")]

     

       460
       460
       +
           InterestsPref(Box<crate::app_bsky::actor::InterestsPref<'a>>),

     

       461
       461
       +
           #[serde(rename = "app.bsky.actor.defs#mutedWordsPref")]

     

       462
       462
       +
           MutedWordsPref(Box<crate::app_bsky::actor::MutedWordsPref<'a>>),

     

       463
       463
       +
           #[serde(rename = "app.bsky.actor.defs#hiddenPostsPref")]

     

       464
       464
       +
           HiddenPostsPref(Box<crate::app_bsky::actor::HiddenPostsPref<'a>>),

     

       465
       465
       +
           #[serde(rename = "app.bsky.actor.defs#bskyAppStatePref")]

     

       466
       466
       +
           BskyAppStatePref(Box<crate::app_bsky::actor::BskyAppStatePref<'a>>),

     

       467
       467
       +
           #[serde(rename = "app.bsky.actor.defs#labelersPref")]

     

       468
       468
       +
           LabelersPref(Box<crate::app_bsky::actor::LabelersPref<'a>>),

     

       469
       469
       +
           #[serde(rename = "app.bsky.actor.defs#postInteractionSettingsPref")]

     

       470
       470
       +
           PostInteractionSettingsPref(

     

       471
       471
       +
               Box<crate::app_bsky::actor::PostInteractionSettingsPref<'a>>,

     

       472
       472
       +
           ),

     

       473
       473
       +
           #[serde(rename = "app.bsky.actor.defs#verificationPrefs")]

     

       474
       474
       +
           VerificationPrefs(Box<crate::app_bsky::actor::VerificationPrefs<'a>>),

     

       475
       475
       +
       }

     

       476
       476
       +
       

     

       477
       477
       +
       pub type Preferences<'a> = Vec<PreferencesItem<'a>>;

     

       410
       478
        
       #[jacquard_derive::lexicon]

     

       411
       479
        
       #[derive(

     

       412
       480
        
           serde::Serialize,

     
···

       705
       773
        
           ///An optional embed associated with the status.

     

       706
       774
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       707
       775
        
           #[serde(borrow)]

     

       708
       708
       -
           pub embed: std::option::Option<StatusViewRecordEmbed<'a>>,

     

       776
       776
       +
           pub embed: std::option::Option<crate::app_bsky::embed::external::View<'a>>,

     

       709
       777
        
           ///The date when this status will expire. The application might choose to no longer return the status after expiration.

     

       710
       778
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       711
       779
        
           pub expires_at: std::option::Option<jacquard_common::types::string::Datetime>,

     
···

       717
       785
        
           ///The status for the account.

     

       718
       786
        
           #[serde(borrow)]

     

       719
       787
        
           pub status: jacquard_common::CowStr<'a>,

     

       720
       720
       -
       }

     

       721
       721
       -
       

     

       722
       722
       -
       #[jacquard_derive::open_union]

     

       723
       723
       -
       #[derive(

     

       724
       724
       -
           serde::Serialize,

     

       725
       725
       -
           serde::Deserialize,

     

       726
       726
       -
           Debug,

     

       727
       727
       -
           Clone,

     

       728
       728
       -
           PartialEq,

     

       729
       729
       -
           Eq,

     

       730
       730
       -
           jacquard_derive::IntoStatic

     

       731
       731
       -
       )]

     

       732
       732
       -
       #[serde(tag = "$type")]

     

       733
       733
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       734
       734
       -
       pub enum StatusViewRecordEmbed<'a> {

     

       735
       735
       -
           #[serde(rename = "app.bsky.embed.external#view")]

     

       736
       736
       -
           ExternalView(Box<crate::app_bsky::embed::external::View<'a>>),

     

       737
       788
        
       }

     

       738
       789
        
       

     

       739
       790
        
       #[jacquard_derive::lexicon]

+1 -18

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

···

       43
       43
        
           ///Self-label values, specific to the Bluesky application, on the overall account.

     

       44
       44
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
        
           #[serde(borrow)]

     

       46
       46
       -
           pub labels: std::option::Option<ProfileRecordLabels<'a>>,

     

       46
       46
       +
           pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,

     

       47
       47
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       48
       48
        
           #[serde(borrow)]

     

       49
       49
        
           pub pinned_post: std::option::Option<

     
···

       56
       56
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       57
       57
        
           #[serde(borrow)]

     

       58
       58
        
           pub website: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       59
       59
       -
       }

     

       60
       60
       -
       

     

       61
       61
       -
       #[jacquard_derive::open_union]

     

       62
       62
       -
       #[derive(

     

       63
       63
       -
           serde::Serialize,

     

       64
       64
       -
           serde::Deserialize,

     

       65
       65
       -
           Debug,

     

       66
       66
       -
           Clone,

     

       67
       67
       -
           PartialEq,

     

       68
       68
       -
           Eq,

     

       69
       69
       -
           jacquard_derive::IntoStatic

     

       70
       70
       -
       )]

     

       71
       71
       -
       #[serde(tag = "$type")]

     

       72
       72
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       73
       73
       -
       pub enum ProfileRecordLabels<'a> {

     

       74
       74
       -
           #[serde(rename = "com.atproto.label.defs#selfLabels")]

     

       75
       75
       -
           DefsSelfLabels(Box<crate::com_atproto::label::SelfLabels<'a>>),

     

       76
       59
        
       }

     

       77
       60
        
       

     

       78
       61
        
       impl jacquard_common::types::collection::Collection for Profile<'_> {

+1 -18

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

···

       43
       43
        
           ///An optional embed associated with the status.

     

       44
       44
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
        
           #[serde(borrow)]

     

       46
       46
       -
           pub embed: std::option::Option<StatusRecordEmbed<'a>>,

     

       46
       46
       +
           pub embed: std::option::Option<crate::app_bsky::embed::external::ExternalRecord<'a>>,

     

       47
       47
        
           ///The status for the account.

     

       48
       48
        
           #[serde(borrow)]

     

       49
       49
        
           pub status: jacquard_common::CowStr<'a>,

     

       50
       50
       -
       }

     

       51
       51
       -
       

     

       52
       52
       -
       #[jacquard_derive::open_union]

     

       53
       53
       -
       #[derive(

     

       54
       54
       -
           serde::Serialize,

     

       55
       55
       -
           serde::Deserialize,

     

       56
       56
       -
           Debug,

     

       57
       57
       -
           Clone,

     

       58
       58
       -
           PartialEq,

     

       59
       59
       -
           Eq,

     

       60
       60
       -
           jacquard_derive::IntoStatic

     

       61
       61
       -
       )]

     

       62
       62
       -
       #[serde(tag = "$type")]

     

       63
       63
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       64
       64
       -
       pub enum StatusRecordEmbed<'a> {

     

       65
       65
       -
           #[serde(rename = "app.bsky.embed.external")]

     

       66
       66
       -
           External(Box<crate::app_bsky::embed::external::ExternalRecord<'a>>),

     

       67
       50
        
       }

     

       68
       51
        
       

     

       69
       52
        
       impl jacquard_common::types::collection::Collection for Status<'_> {

+5 -5

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

···

       42
       42
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       43
       43
        
           pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       44
       44
        
           #[serde(borrow)]

     

       45
       45
       -
           pub item: BookmarkViewRecordItem<'a>,

     

       45
       45
       +
           pub item: BookmarkViewItem<'a>,

     

       46
       46
        
           ///A strong ref to the bookmarked record.

     

       47
       47
        
           #[serde(borrow)]

     

       48
       48
        
           pub subject: crate::com_atproto::repo::strong_ref::StrongRef<'a>,

     
···

       60
       60
        
       )]

     

       61
       61
        
       #[serde(tag = "$type")]

     

       62
       62
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       63
       63
       -
       pub enum BookmarkViewRecordItem<'a> {

     

       63
       63
       +
       pub enum BookmarkViewItem<'a> {

     

       64
       64
        
           #[serde(rename = "app.bsky.feed.defs#blockedPost")]

     

       65
       65
       -
           DefsBlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),

     

       65
       65
       +
           BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),

     

       66
       66
        
           #[serde(rename = "app.bsky.feed.defs#notFoundPost")]

     

       67
       67
       -
           DefsNotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),

     

       67
       67
       +
           NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),

     

       68
       68
        
           #[serde(rename = "app.bsky.feed.defs#postView")]

     

       69
       69
       -
           DefsPostView(Box<crate::app_bsky::feed::PostView<'a>>),

     

       69
       69
       +
           PostView(Box<crate::app_bsky::feed::PostView<'a>>),

     

       70
       70
        
       }

+2 -15

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

···

       41
       41
        
           PartialEq,

     

       42
       42
        
           Eq,

     

       43
       43
        
           thiserror::Error,

     

       44
       44
       -
           miette::Diagnostic

     

       44
       44
       +
           miette::Diagnostic,

     

       45
       45
       +
           jacquard_derive::IntoStatic

     

       45
       46
        
       )]

     

       46
       47
        
       #[serde(tag = "error", content = "message")]

     

       47
       48
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       62
       63
        
                       Ok(())

     

       63
       64
        
                   }

     

       64
       65
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       65
       65
       -
               }

     

       66
       66
       -
           }

     

       67
       67
       -
       }

     

       68
       68
       -
       

     

       69
       69
       -
       impl jacquard_common::IntoStatic for CreateBookmarkError<'_> {

     

       70
       70
       -
           type Output = CreateBookmarkError<'static>;

     

       71
       71
       -
           fn into_static(self) -> Self::Output {

     

       72
       72
       -
               match self {

     

       73
       73
       -
                   CreateBookmarkError::UnsupportedCollection(v) => {

     

       74
       74
       -
                       CreateBookmarkError::UnsupportedCollection(v.into_static())

     

       75
       75
       -
                   }

     

       76
       76
       -
                   CreateBookmarkError::Unknown(v) => {

     

       77
       77
       -
                       CreateBookmarkError::Unknown(v.into_static())

     

       78
       78
       -
                   }

     

       79
       66
        
               }

     

       80
       67
        
           }

     

       81
       68
        
       }

+2 -15

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

···

       39
       39
        
           PartialEq,

     

       40
       40
        
           Eq,

     

       41
       41
        
           thiserror::Error,

     

       42
       42
       -
           miette::Diagnostic

     

       42
       42
       +
           miette::Diagnostic,

     

       43
       43
       +
           jacquard_derive::IntoStatic

     

       43
       44
        
       )]

     

       44
       45
        
       #[serde(tag = "error", content = "message")]

     

       45
       46
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       60
       61
        
                       Ok(())

     

       61
       62
        
                   }

     

       62
       63
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       63
       63
       -
               }

     

       64
       64
       -
           }

     

       65
       65
       -
       }

     

       66
       66
       -
       

     

       67
       67
       -
       impl jacquard_common::IntoStatic for DeleteBookmarkError<'_> {

     

       68
       68
       -
           type Output = DeleteBookmarkError<'static>;

     

       69
       69
       -
           fn into_static(self) -> Self::Output {

     

       70
       70
       -
               match self {

     

       71
       71
       -
                   DeleteBookmarkError::UnsupportedCollection(v) => {

     

       72
       72
       -
                       DeleteBookmarkError::UnsupportedCollection(v.into_static())

     

       73
       73
       -
                   }

     

       74
       74
       -
                   DeleteBookmarkError::Unknown(v) => {

     

       75
       75
       -
                       DeleteBookmarkError::Unknown(v.into_static())

     

       76
       76
       -
                   }

     

       77
       64
        
               }

     

       78
       65
        
           }

     

       79
       66
        
       }

+40 -7

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

···

       34
       34
        
       #[serde(rename_all = "camelCase")]

     

       35
       35
        
       pub struct View<'a> {

     

       36
       36
        
           #[serde(borrow)]

     

       37
       37
       -
           pub record: ViewRecordRecord<'a>,

     

       37
       37
       +
           pub record: ViewUnionRecord<'a>,

     

       38
       38
        
       }

     

       39
       39
        
       

     

       40
       40
        
       #[jacquard_derive::open_union]

     
···

       49
       49
        
       )]

     

       50
       50
        
       #[serde(tag = "$type")]

     

       51
       51
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       52
       52
       -
       pub enum ViewRecordRecord<'a> {

     

       52
       52
       +
       pub enum ViewUnionRecord<'a> {

     

       53
       53
       +
           #[serde(rename = "app.bsky.embed.record#viewRecord")]

     

       54
       54
       +
           ViewRecord(Box<crate::app_bsky::embed::record::ViewRecord<'a>>),

     

       55
       55
       +
           #[serde(rename = "app.bsky.embed.record#viewNotFound")]

     

       56
       56
       +
           ViewNotFound(Box<crate::app_bsky::embed::record::ViewNotFound<'a>>),

     

       57
       57
       +
           #[serde(rename = "app.bsky.embed.record#viewBlocked")]

     

       58
       58
       +
           ViewBlocked(Box<crate::app_bsky::embed::record::ViewBlocked<'a>>),

     

       59
       59
       +
           #[serde(rename = "app.bsky.embed.record#viewDetached")]

     

       60
       60
       +
           ViewDetached(Box<crate::app_bsky::embed::record::ViewDetached<'a>>),

     

       53
       61
        
           #[serde(rename = "app.bsky.feed.defs#generatorView")]

     

       54
       54
       -
           DefsGeneratorView(Box<crate::app_bsky::feed::GeneratorView<'a>>),

     

       62
       62
       +
           GeneratorView(Box<crate::app_bsky::feed::GeneratorView<'a>>),

     

       55
       63
        
           #[serde(rename = "app.bsky.graph.defs#listView")]

     

       56
       56
       -
           DefsListView(Box<crate::app_bsky::graph::ListView<'a>>),

     

       64
       64
       +
           ListView(Box<crate::app_bsky::graph::ListView<'a>>),

     

       57
       65
        
           #[serde(rename = "app.bsky.labeler.defs#labelerView")]

     

       58
       58
       -
           DefsLabelerView(Box<crate::app_bsky::labeler::LabelerView<'a>>),

     

       66
       66
       +
           LabelerView(Box<crate::app_bsky::labeler::LabelerView<'a>>),

     

       59
       67
        
           #[serde(rename = "app.bsky.graph.defs#starterPackViewBasic")]

     

       60
       60
       -
           DefsStarterPackViewBasic(Box<crate::app_bsky::graph::StarterPackViewBasic<'a>>),

     

       68
       68
       +
           StarterPackViewBasic(Box<crate::app_bsky::graph::StarterPackViewBasic<'a>>),

     

       61
       69
        
       }

     

       62
       70
        
       

     

       63
       71
        
       #[jacquard_derive::lexicon]

     
···

       131
       139
        
           pub cid: jacquard_common::types::string::Cid<'a>,

     

       132
       140
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       133
       141
        
           #[serde(borrow)]

     

       134
       134
       -
           pub embeds: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       142
       142
       +
           pub embeds: std::option::Option<Vec<ViewRecordEmbedsItem<'a>>>,

     

       135
       143
        
           pub indexed_at: jacquard_common::types::string::Datetime,

     

       136
       144
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       137
       145
        
           #[serde(borrow)]

     
···

       149
       157
        
           ///The record data itself.

     

       150
       158
        
           #[serde(borrow)]

     

       151
       159
        
           pub value: jacquard_common::types::value::Data<'a>,

     

       160
       160
       +
       }

     

       161
       161
       +
       

     

       162
       162
       +
       #[jacquard_derive::open_union]

     

       163
       163
       +
       #[derive(

     

       164
       164
       +
           serde::Serialize,

     

       165
       165
       +
           serde::Deserialize,

     

       166
       166
       +
           Debug,

     

       167
       167
       +
           Clone,

     

       168
       168
       +
           PartialEq,

     

       169
       169
       +
           Eq,

     

       170
       170
       +
           jacquard_derive::IntoStatic

     

       171
       171
       +
       )]

     

       172
       172
       +
       #[serde(tag = "$type")]

     

       173
       173
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       174
       174
       +
       pub enum ViewRecordEmbedsItem<'a> {

     

       175
       175
       +
           #[serde(rename = "app.bsky.embed.images#view")]

     

       176
       176
       +
           ImagesView(Box<crate::app_bsky::embed::images::View<'a>>),

     

       177
       177
       +
           #[serde(rename = "app.bsky.embed.video#view")]

     

       178
       178
       +
           VideoView(Box<crate::app_bsky::embed::video::View<'a>>),

     

       179
       179
       +
           #[serde(rename = "app.bsky.embed.external#view")]

     

       180
       180
       +
           ExternalView(Box<crate::app_bsky::embed::external::View<'a>>),

     

       181
       181
       +
           #[serde(rename = "app.bsky.embed.record#view")]

     

       182
       182
       +
           View(Box<crate::app_bsky::embed::record::View<'a>>),

     

       183
       183
       +
           #[serde(rename = "app.bsky.embed.recordWithMedia#view")]

     

       184
       184
       +
           RecordWithMediaView(Box<crate::app_bsky::embed::record_with_media::View<'a>>),

     

       152
       185
        
       }

+4 -4

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

···

       18
       18
        
       #[serde(rename_all = "camelCase")]

     

       19
       19
        
       pub struct RecordWithMedia<'a> {

     

       20
       20
        
           #[serde(borrow)]

     

       21
       21
       -
           pub media: RecordWithMediaRecordMedia<'a>,

     

       21
       21
       +
           pub media: RecordWithMediaMedia<'a>,

     

       22
       22
        
           #[serde(borrow)]

     

       23
       23
        
           pub record: crate::app_bsky::embed::record::Record<'a>,

     

       24
       24
        
       }

     
···

       35
       35
        
       )]

     

       36
       36
        
       #[serde(tag = "$type")]

     

       37
       37
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       38
       38
       -
       pub enum RecordWithMediaRecordMedia<'a> {

     

       38
       38
       +
       pub enum RecordWithMediaMedia<'a> {

     

       39
       39
        
           #[serde(rename = "app.bsky.embed.images")]

     

       40
       40
        
           Images(Box<crate::app_bsky::embed::images::Images<'a>>),

     

       41
       41
        
           #[serde(rename = "app.bsky.embed.video")]

     
···

       57
       57
        
       #[serde(rename_all = "camelCase")]

     

       58
       58
        
       pub struct View<'a> {

     

       59
       59
        
           #[serde(borrow)]

     

       60
       60
       -
           pub media: ViewRecordMedia<'a>,

     

       60
       60
       +
           pub media: ViewMedia<'a>,

     

       61
       61
        
           #[serde(borrow)]

     

       62
       62
        
           pub record: crate::app_bsky::embed::record::View<'a>,

     

       63
       63
        
       }

     
···

       74
       74
        
       )]

     

       75
       75
        
       #[serde(tag = "$type")]

     

       76
       76
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       77
       77
       -
       pub enum ViewRecordMedia<'a> {

     

       77
       77
       +
       pub enum ViewMedia<'a> {

     

       78
       78
        
           #[serde(rename = "app.bsky.embed.images#view")]

     

       79
       79
        
           ImagesView(Box<crate::app_bsky::embed::images::View<'a>>),

     

       80
       80
        
           #[serde(rename = "app.bsky.embed.video#view")]

+70 -13

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

···

       196
       196
        
           pub post: crate::app_bsky::feed::PostView<'a>,

     

       197
       197
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       198
       198
        
           #[serde(borrow)]

     

       199
       199
       -
           pub reason: std::option::Option<FeedViewPostRecordReason<'a>>,

     

       199
       199
       +
           pub reason: std::option::Option<FeedViewPostReason<'a>>,

     

       200
       200
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       201
       201
        
           #[serde(borrow)]

     

       202
       202
        
           pub reply: std::option::Option<crate::app_bsky::feed::ReplyRef<'a>>,

     
···

       218
       218
        
       )]

     

       219
       219
        
       #[serde(tag = "$type")]

     

       220
       220
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       221
       221
       -
       pub enum FeedViewPostRecordReason<'a> {}

     

       221
       221
       +
       pub enum FeedViewPostReason<'a> {

     

       222
       222
       +
           #[serde(rename = "app.bsky.feed.defs#reasonRepost")]

     

       223
       223
       +
           ReasonRepost(Box<crate::app_bsky::feed::ReasonRepost<'a>>),

     

       224
       224
       +
           #[serde(rename = "app.bsky.feed.defs#reasonPin")]

     

       225
       225
       +
           ReasonPin(Box<crate::app_bsky::feed::ReasonPin<'a>>),

     

       226
       226
       +
       }

     

       227
       227
       +
       

     

       222
       228
        
       #[jacquard_derive::lexicon]

     

       223
       229
        
       #[derive(

     

       224
       230
        
           serde::Serialize,

     
···

       458
       464
        
           pub cid: jacquard_common::types::string::Cid<'a>,

     

       459
       465
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       460
       466
        
           #[serde(borrow)]

     

       461
       461
       -
           pub embed: std::option::Option<PostViewRecordEmbed<'a>>,

     

       467
       467
       +
           pub embed: std::option::Option<PostViewEmbed<'a>>,

     

       462
       468
        
           pub indexed_at: jacquard_common::types::string::Datetime,

     

       463
       469
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       464
       470
        
           #[serde(borrow)]

     
···

       495
       501
        
       )]

     

       496
       502
        
       #[serde(tag = "$type")]

     

       497
       503
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       498
       498
       -
       pub enum PostViewRecordEmbed<'a> {

     

       504
       504
       +
       pub enum PostViewEmbed<'a> {

     

       499
       505
        
           #[serde(rename = "app.bsky.embed.images#view")]

     

       500
       506
        
           ImagesView(Box<crate::app_bsky::embed::images::View<'a>>),

     

       501
       507
        
           #[serde(rename = "app.bsky.embed.video#view")]

     
···

       562
       568
        
               crate::app_bsky::actor::ProfileViewBasic<'a>,

     

       563
       569
        
           >,

     

       564
       570
        
           #[serde(borrow)]

     

       565
       565
       -
           pub parent: ReplyRefRecordParent<'a>,

     

       571
       571
       +
           pub parent: ReplyRefParent<'a>,

     

       566
       572
        
           #[serde(borrow)]

     

       567
       567
       -
           pub root: ReplyRefRecordRoot<'a>,

     

       573
       573
       +
           pub root: ReplyRefRoot<'a>,

     

       568
       574
        
       }

     

       569
       575
        
       

     

       570
       576
        
       #[jacquard_derive::open_union]

     
···

       579
       585
        
       )]

     

       580
       586
        
       #[serde(tag = "$type")]

     

       581
       587
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       582
       582
       -
       pub enum ReplyRefRecordParent<'a> {}

     

       588
       588
       +
       pub enum ReplyRefParent<'a> {

     

       589
       589
       +
           #[serde(rename = "app.bsky.feed.defs#postView")]

     

       590
       590
       +
           PostView(Box<crate::app_bsky::feed::PostView<'a>>),

     

       591
       591
       +
           #[serde(rename = "app.bsky.feed.defs#notFoundPost")]

     

       592
       592
       +
           NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),

     

       593
       593
       +
           #[serde(rename = "app.bsky.feed.defs#blockedPost")]

     

       594
       594
       +
           BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),

     

       595
       595
       +
       }

     

       596
       596
       +
       

     

       583
       597
        
       #[jacquard_derive::open_union]

     

       584
       598
        
       #[derive(

     

       585
       599
        
           serde::Serialize,

     
···

       592
       606
        
       )]

     

       593
       607
        
       #[serde(tag = "$type")]

     

       594
       608
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       595
       595
       -
       pub enum ReplyRefRecordRoot<'a> {}

     

       609
       609
       +
       pub enum ReplyRefRoot<'a> {

     

       610
       610
       +
           #[serde(rename = "app.bsky.feed.defs#postView")]

     

       611
       611
       +
           PostView(Box<crate::app_bsky::feed::PostView<'a>>),

     

       612
       612
       +
           #[serde(rename = "app.bsky.feed.defs#notFoundPost")]

     

       613
       613
       +
           NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),

     

       614
       614
       +
           #[serde(rename = "app.bsky.feed.defs#blockedPost")]

     

       615
       615
       +
           BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),

     

       616
       616
       +
       }

     

       617
       617
       +
       

     

       596
       618
        
       ///Request that less content like the given feed item be shown in the feed

     

       597
       619
        
       #[derive(

     

       598
       620
        
           serde::Serialize,

     
···

       649
       671
        
           pub post: jacquard_common::types::string::AtUri<'a>,

     

       650
       672
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       651
       673
        
           #[serde(borrow)]

     

       652
       652
       -
           pub reason: std::option::Option<SkeletonFeedPostRecordReason<'a>>,

     

       674
       674
       +
           pub reason: std::option::Option<SkeletonFeedPostReason<'a>>,

     

       653
       675
        
       }

     

       654
       676
        
       

     

       655
       677
        
       #[jacquard_derive::open_union]

     
···

       664
       686
        
       )]

     

       665
       687
        
       #[serde(tag = "$type")]

     

       666
       688
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       667
       667
       -
       pub enum SkeletonFeedPostRecordReason<'a> {}

     

       689
       689
       +
       pub enum SkeletonFeedPostReason<'a> {

     

       690
       690
       +
           #[serde(rename = "app.bsky.feed.defs#skeletonReasonRepost")]

     

       691
       691
       +
           SkeletonReasonRepost(Box<crate::app_bsky::feed::SkeletonReasonRepost<'a>>),

     

       692
       692
       +
           #[serde(rename = "app.bsky.feed.defs#skeletonReasonPin")]

     

       693
       693
       +
           SkeletonReasonPin(Box<crate::app_bsky::feed::SkeletonReasonPin<'a>>),

     

       694
       694
       +
       }

     

       695
       695
       +
       

     

       668
       696
        
       #[jacquard_derive::lexicon]

     

       669
       697
        
       #[derive(

     

       670
       698
        
           serde::Serialize,

     
···

       725
       753
        
       pub struct ThreadViewPost<'a> {

     

       726
       754
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       727
       755
        
           #[serde(borrow)]

     

       728
       728
       -
           pub parent: std::option::Option<ThreadViewPostRecordParent<'a>>,

     

       756
       756
       +
           pub parent: std::option::Option<ThreadViewPostParent<'a>>,

     

       729
       757
        
           #[serde(borrow)]

     

       730
       758
        
           pub post: crate::app_bsky::feed::PostView<'a>,

     

       731
       759
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       732
       760
        
           #[serde(borrow)]

     

       733
       733
       -
           pub replies: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       761
       761
       +
           pub replies: std::option::Option<Vec<ThreadViewPostRepliesItem<'a>>>,

     

       734
       762
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       735
       763
        
           #[serde(borrow)]

     

       736
       764
        
           pub thread_context: std::option::Option<crate::app_bsky::feed::ThreadContext<'a>>,

     
···

       748
       776
        
       )]

     

       749
       777
        
       #[serde(tag = "$type")]

     

       750
       778
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       751
       751
       -
       pub enum ThreadViewPostRecordParent<'a> {}

     

       779
       779
       +
       pub enum ThreadViewPostParent<'a> {

     

       780
       780
       +
           #[serde(rename = "app.bsky.feed.defs#threadViewPost")]

     

       781
       781
       +
           ThreadViewPost(Box<crate::app_bsky::feed::ThreadViewPost<'a>>),

     

       782
       782
       +
           #[serde(rename = "app.bsky.feed.defs#notFoundPost")]

     

       783
       783
       +
           NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),

     

       784
       784
       +
           #[serde(rename = "app.bsky.feed.defs#blockedPost")]

     

       785
       785
       +
           BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),

     

       786
       786
       +
       }

     

       787
       787
       +
       

     

       788
       788
       +
       #[jacquard_derive::open_union]

     

       789
       789
       +
       #[derive(

     

       790
       790
       +
           serde::Serialize,

     

       791
       791
       +
           serde::Deserialize,

     

       792
       792
       +
           Debug,

     

       793
       793
       +
           Clone,

     

       794
       794
       +
           PartialEq,

     

       795
       795
       +
           Eq,

     

       796
       796
       +
           jacquard_derive::IntoStatic

     

       797
       797
       +
       )]

     

       798
       798
       +
       #[serde(tag = "$type")]

     

       799
       799
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       800
       800
       +
       pub enum ThreadViewPostRepliesItem<'a> {

     

       801
       801
       +
           #[serde(rename = "app.bsky.feed.defs#threadViewPost")]

     

       802
       802
       +
           ThreadViewPost(Box<crate::app_bsky::feed::ThreadViewPost<'a>>),

     

       803
       803
       +
           #[serde(rename = "app.bsky.feed.defs#notFoundPost")]

     

       804
       804
       +
           NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),

     

       805
       805
       +
           #[serde(rename = "app.bsky.feed.defs#blockedPost")]

     

       806
       806
       +
           BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),

     

       807
       807
       +
       }

     

       808
       808
       +
       

     

       752
       809
        
       #[jacquard_derive::lexicon]

     

       753
       810
        
       #[derive(

     

       754
       811
        
           serde::Serialize,

+1 -18

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

···

       43
       43
        
           ///Self-label values

     

       44
       44
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
        
           #[serde(borrow)]

     

       46
       46
       -
           pub labels: std::option::Option<GeneratorRecordLabels<'a>>,

     

       47
       47
       -
       }

     

       48
       48
       -
       

     

       49
       49
       -
       #[jacquard_derive::open_union]

     

       50
       50
       -
       #[derive(

     

       51
       51
       -
           serde::Serialize,

     

       52
       52
       -
           serde::Deserialize,

     

       53
       53
       -
           Debug,

     

       54
       54
       -
           Clone,

     

       55
       55
       -
           PartialEq,

     

       56
       56
       -
           Eq,

     

       57
       57
       -
           jacquard_derive::IntoStatic

     

       58
       58
       -
       )]

     

       59
       59
       -
       #[serde(tag = "$type")]

     

       60
       60
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       61
       61
       -
       pub enum GeneratorRecordLabels<'a> {

     

       62
       62
       -
           #[serde(rename = "com.atproto.label.defs#selfLabels")]

     

       63
       63
       -
           DefsSelfLabels(Box<crate::com_atproto::label::SelfLabels<'a>>),

     

       46
       46
       +
           pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,

     

       64
       47
        
       }

     

       65
       48
        
       

     

       66
       49
        
       impl jacquard_common::types::collection::Collection for Generator<'_> {

+2 -18

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

···

       57
       57
        
           PartialEq,

     

       58
       58
        
           Eq,

     

       59
       59
        
           thiserror::Error,

     

       60
       60
       -
           miette::Diagnostic

     

       60
       60
       +
           miette::Diagnostic,

     

       61
       61
       +
           jacquard_derive::IntoStatic

     

       61
       62
        
       )]

     

       62
       63
        
       #[serde(tag = "error", content = "message")]

     

       63
       64
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       86
       87
        
                       Ok(())

     

       87
       88
        
                   }

     

       88
       89
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       89
       89
       -
               }

     

       90
       90
       -
           }

     

       91
       91
       -
       }

     

       92
       92
       -
       

     

       93
       93
       -
       impl jacquard_common::IntoStatic for GetActorLikesError<'_> {

     

       94
       94
       -
           type Output = GetActorLikesError<'static>;

     

       95
       95
       -
           fn into_static(self) -> Self::Output {

     

       96
       96
       -
               match self {

     

       97
       97
       -
                   GetActorLikesError::BlockedActor(v) => {

     

       98
       98
       -
                       GetActorLikesError::BlockedActor(v.into_static())

     

       99
       99
       -
                   }

     

       100
       100
       -
                   GetActorLikesError::BlockedByActor(v) => {

     

       101
       101
       -
                       GetActorLikesError::BlockedByActor(v.into_static())

     

       102
       102
       -
                   }

     

       103
       103
       -
                   GetActorLikesError::Unknown(v) => {

     

       104
       104
       -
                       GetActorLikesError::Unknown(v.into_static())

     

       105
       105
       -
                   }

     

       106
       90
        
               }

     

       107
       91
        
           }

     

       108
       92
        
       }

+2 -18

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

···

       65
       65
        
           PartialEq,

     

       66
       66
        
           Eq,

     

       67
       67
        
           thiserror::Error,

     

       68
       68
       -
           miette::Diagnostic

     

       68
       68
       +
           miette::Diagnostic,

     

       69
       69
       +
           jacquard_derive::IntoStatic

     

       69
       70
        
       )]

     

       70
       71
        
       #[serde(tag = "error", content = "message")]

     

       71
       72
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       94
       95
        
                       Ok(())

     

       95
       96
        
                   }

     

       96
       97
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       97
       97
       -
               }

     

       98
       98
       -
           }

     

       99
       99
       -
       }

     

       100
       100
       -
       

     

       101
       101
       -
       impl jacquard_common::IntoStatic for GetAuthorFeedError<'_> {

     

       102
       102
       -
           type Output = GetAuthorFeedError<'static>;

     

       103
       103
       -
           fn into_static(self) -> Self::Output {

     

       104
       104
       -
               match self {

     

       105
       105
       -
                   GetAuthorFeedError::BlockedActor(v) => {

     

       106
       106
       -
                       GetAuthorFeedError::BlockedActor(v.into_static())

     

       107
       107
       -
                   }

     

       108
       108
       -
                   GetAuthorFeedError::BlockedByActor(v) => {

     

       109
       109
       -
                       GetAuthorFeedError::BlockedByActor(v.into_static())

     

       110
       110
       -
                   }

     

       111
       111
       -
                   GetAuthorFeedError::Unknown(v) => {

     

       112
       112
       -
                       GetAuthorFeedError::Unknown(v.into_static())

     

       113
       113
       -
                   }

     

       114
       98
        
               }

     

       115
       99
        
           }

     

       116
       100
        
       }

+2 -11

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

···

       57
       57
        
           PartialEq,

     

       58
       58
        
           Eq,

     

       59
       59
        
           thiserror::Error,

     

       60
       60
       -
           miette::Diagnostic

     

       60
       60
       +
           miette::Diagnostic,

     

       61
       61
       +
           jacquard_derive::IntoStatic

     

       61
       62
        
       )]

     

       62
       63
        
       #[serde(tag = "error", content = "message")]

     

       63
       64
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       77
       78
        
                       Ok(())

     

       78
       79
        
                   }

     

       79
       80
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       80
       80
       -
               }

     

       81
       81
       -
           }

     

       82
       82
       -
       }

     

       83
       83
       -
       

     

       84
       84
       -
       impl jacquard_common::IntoStatic for GetFeedError<'_> {

     

       85
       85
       -
           type Output = GetFeedError<'static>;

     

       86
       86
       -
           fn into_static(self) -> Self::Output {

     

       87
       87
       -
               match self {

     

       88
       88
       -
                   GetFeedError::UnknownFeed(v) => GetFeedError::UnknownFeed(v.into_static()),

     

       89
       89
       -
                   GetFeedError::Unknown(v) => GetFeedError::Unknown(v.into_static()),

     

       90
       81
        
               }

     

       91
       82
        
           }

     

       92
       83
        
       }

+2 -15

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

···

       61
       61
        
           PartialEq,

     

       62
       62
        
           Eq,

     

       63
       63
        
           thiserror::Error,

     

       64
       64
       -
           miette::Diagnostic

     

       64
       64
       +
           miette::Diagnostic,

     

       65
       65
       +
           jacquard_derive::IntoStatic

     

       65
       66
        
       )]

     

       66
       67
        
       #[serde(tag = "error", content = "message")]

     

       67
       68
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       81
       82
        
                       Ok(())

     

       82
       83
        
                   }

     

       83
       84
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       84
       84
       -
               }

     

       85
       85
       -
           }

     

       86
       86
       -
       }

     

       87
       87
       -
       

     

       88
       88
       -
       impl jacquard_common::IntoStatic for GetFeedSkeletonError<'_> {

     

       89
       89
       -
           type Output = GetFeedSkeletonError<'static>;

     

       90
       90
       -
           fn into_static(self) -> Self::Output {

     

       91
       91
       -
               match self {

     

       92
       92
       -
                   GetFeedSkeletonError::UnknownFeed(v) => {

     

       93
       93
       -
                       GetFeedSkeletonError::UnknownFeed(v.into_static())

     

       94
       94
       -
                   }

     

       95
       95
       -
                   GetFeedSkeletonError::Unknown(v) => {

     

       96
       96
       -
                       GetFeedSkeletonError::Unknown(v.into_static())

     

       97
       97
       -
                   }

     

       98
       85
        
               }

     

       99
       86
        
           }

     

       100
       87
        
       }

+2 -13

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

···

       57
       57
        
           PartialEq,

     

       58
       58
        
           Eq,

     

       59
       59
        
           thiserror::Error,

     

       60
       60
       -
           miette::Diagnostic

     

       60
       60
       +
           miette::Diagnostic,

     

       61
       61
       +
           jacquard_derive::IntoStatic

     

       61
       62
        
       )]

     

       62
       63
        
       #[serde(tag = "error", content = "message")]

     

       63
       64
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       77
       78
        
                       Ok(())

     

       78
       79
        
                   }

     

       79
       80
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       80
       80
       -
               }

     

       81
       81
       -
           }

     

       82
       82
       -
       }

     

       83
       83
       -
       

     

       84
       84
       -
       impl jacquard_common::IntoStatic for GetListFeedError<'_> {

     

       85
       85
       -
           type Output = GetListFeedError<'static>;

     

       86
       86
       -
           fn into_static(self) -> Self::Output {

     

       87
       87
       -
               match self {

     

       88
       88
       -
                   GetListFeedError::UnknownList(v) => {

     

       89
       89
       -
                       GetListFeedError::UnknownList(v.into_static())

     

       90
       90
       -
                   }

     

       91
       91
       -
                   GetListFeedError::Unknown(v) => GetListFeedError::Unknown(v.into_static()),

     

       92
       81
        
               }

     

       93
       82
        
           }

     

       94
       83
        
       }

+7 -20

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

···

       41
       41
        
       #[serde(rename_all = "camelCase")]

     

       42
       42
        
       pub struct GetPostThreadOutput<'a> {

     

       43
       43
        
           #[serde(borrow)]

     

       44
       44
       -
           pub thread: GetPostThreadOutputRecordThread<'a>,

     

       44
       44
       +
           pub thread: GetPostThreadOutputThread<'a>,

     

       45
       45
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       46
       46
        
           #[serde(borrow)]

     

       47
       47
        
           pub threadgate: std::option::Option<crate::app_bsky::feed::ThreadgateView<'a>>,

     
···

       59
       59
        
       )]

     

       60
       60
        
       #[serde(tag = "$type")]

     

       61
       61
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       62
       62
       -
       pub enum GetPostThreadOutputRecordThread<'a> {

     

       62
       62
       +
       pub enum GetPostThreadOutputThread<'a> {

     

       63
       63
        
           #[serde(rename = "app.bsky.feed.defs#threadViewPost")]

     

       64
       64
       -
           DefsThreadViewPost(Box<crate::app_bsky::feed::ThreadViewPost<'a>>),

     

       64
       64
       +
           ThreadViewPost(Box<crate::app_bsky::feed::ThreadViewPost<'a>>),

     

       65
       65
        
           #[serde(rename = "app.bsky.feed.defs#notFoundPost")]

     

       66
       66
       -
           DefsNotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),

     

       66
       66
       +
           NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),

     

       67
       67
        
           #[serde(rename = "app.bsky.feed.defs#blockedPost")]

     

       68
       68
       -
           DefsBlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),

     

       68
       68
       +
           BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),

     

       69
       69
        
       }

     

       70
       70
        
       

     

       71
       71
        
       #[jacquard_derive::open_union]

     
···

       77
       77
        
           PartialEq,

     

       78
       78
        
           Eq,

     

       79
       79
        
           thiserror::Error,

     

       80
       80
       -
           miette::Diagnostic

     

       80
       80
       +
           miette::Diagnostic,

     

       81
       81
       +
           jacquard_derive::IntoStatic

     

       81
       82
        
       )]

     

       82
       83
        
       #[serde(tag = "error", content = "message")]

     

       83
       84
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       97
       98
        
                       Ok(())

     

       98
       99
        
                   }

     

       99
       100
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       100
       100
       -
               }

     

       101
       101
       -
           }

     

       102
       102
       -
       }

     

       103
       103
       -
       

     

       104
       104
       -
       impl jacquard_common::IntoStatic for GetPostThreadError<'_> {

     

       105
       105
       -
           type Output = GetPostThreadError<'static>;

     

       106
       106
       -
           fn into_static(self) -> Self::Output {

     

       107
       107
       -
               match self {

     

       108
       108
       -
                   GetPostThreadError::NotFound(v) => {

     

       109
       109
       -
                       GetPostThreadError::NotFound(v.into_static())

     

       110
       110
       -
                   }

     

       111
       111
       -
                   GetPostThreadError::Unknown(v) => {

     

       112
       112
       -
                       GetPostThreadError::Unknown(v.into_static())

     

       113
       113
       -
                   }

     

       114
       101
        
               }

     

       115
       102
        
           }

     

       116
       103
        
       }

+3 -20

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

···

       44
       44
        
           pub created_at: jacquard_common::types::string::Datetime,

     

       45
       45
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       46
       46
        
           #[serde(borrow)]

     

       47
       47
       -
           pub embed: std::option::Option<PostRecordEmbed<'a>>,

     

       47
       47
       +
           pub embed: std::option::Option<PostEmbed<'a>>,

     

       48
       48
        
           ///DEPRECATED: replaced by app.bsky.richtext.facet.

     

       49
       49
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       50
       50
        
           #[serde(borrow)]

     
···

       56
       56
        
           ///Self-label values for this post. Effectively content warnings.

     

       57
       57
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       58
       58
        
           #[serde(borrow)]

     

       59
       59
       -
           pub labels: std::option::Option<PostRecordLabels<'a>>,

     

       59
       59
       +
           pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,

     

       60
       60
        
           ///Indicates human language of post primary text content.

     

       61
       61
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       62
       62
        
           pub langs: std::option::Option<Vec<jacquard_common::types::string::Language>>,

     
···

       84
       84
        
       )]

     

       85
       85
        
       #[serde(tag = "$type")]

     

       86
       86
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       87
       87
       -
       pub enum PostRecordEmbed<'a> {

     

       87
       87
       +
       pub enum PostEmbed<'a> {

     

       88
       88
        
           #[serde(rename = "app.bsky.embed.images")]

     

       89
       89
        
           Images(Box<crate::app_bsky::embed::images::Images<'a>>),

     

       90
       90
        
           #[serde(rename = "app.bsky.embed.video")]

     
···

       95
       95
        
           Record(Box<crate::app_bsky::embed::record::Record<'a>>),

     

       96
       96
        
           #[serde(rename = "app.bsky.embed.recordWithMedia")]

     

       97
       97
        
           RecordWithMedia(Box<crate::app_bsky::embed::record_with_media::RecordWithMedia<'a>>),

     

       98
       98
       -
       }

     

       99
       99
       -
       

     

       100
       100
       -
       #[jacquard_derive::open_union]

     

       101
       101
       -
       #[derive(

     

       102
       102
       -
           serde::Serialize,

     

       103
       103
       -
           serde::Deserialize,

     

       104
       104
       -
           Debug,

     

       105
       105
       -
           Clone,

     

       106
       106
       -
           PartialEq,

     

       107
       107
       -
           Eq,

     

       108
       108
       -
           jacquard_derive::IntoStatic

     

       109
       109
       -
       )]

     

       110
       110
       -
       #[serde(tag = "$type")]

     

       111
       111
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       112
       112
       -
       pub enum PostRecordLabels<'a> {

     

       113
       113
       -
           #[serde(rename = "com.atproto.label.defs#selfLabels")]

     

       114
       114
       -
           DefsSelfLabels(Box<crate::com_atproto::label::SelfLabels<'a>>),

     

       115
       98
        
       }

     

       116
       99
        
       

     

       117
       100
        
       impl jacquard_common::types::collection::Collection for Post<'_> {

+1 -1

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

···

       42
       42
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       43
       43
        
           #[serde(borrow)]

     

       44
       44
        
           pub embedding_rules: std::option::Option<

     

       45
       45
       -
               Vec<jacquard_common::types::value::Data<'a>>,

     

       45
       45
       +
               Vec<crate::app_bsky::feed::postgate::DisableRule<'a>>,

     

       46
       46
        
           >,

     

       47
       47
        
           ///Reference (AT-URI) to the post record.

     

       48
       48
        
           #[serde(borrow)]

+2 -13

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

···

       92
       92
        
           PartialEq,

     

       93
       93
        
           Eq,

     

       94
       94
        
           thiserror::Error,

     

       95
       95
       -
           miette::Diagnostic

     

       95
       95
       +
           miette::Diagnostic,

     

       96
       96
       +
           jacquard_derive::IntoStatic

     

       96
       97
        
       )]

     

       97
       98
        
       #[serde(tag = "error", content = "message")]

     

       98
       99
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       112
       113
        
                       Ok(())

     

       113
       114
        
                   }

     

       114
       115
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       115
       115
       -
               }

     

       116
       116
       -
           }

     

       117
       117
       -
       }

     

       118
       118
       -
       

     

       119
       119
       -
       impl jacquard_common::IntoStatic for SearchPostsError<'_> {

     

       120
       120
       -
           type Output = SearchPostsError<'static>;

     

       121
       121
       -
           fn into_static(self) -> Self::Output {

     

       122
       122
       -
               match self {

     

       123
       123
       -
                   SearchPostsError::BadQueryString(v) => {

     

       124
       124
       -
                       SearchPostsError::BadQueryString(v.into_static())

     

       125
       125
       -
                   }

     

       126
       126
       -
                   SearchPostsError::Unknown(v) => SearchPostsError::Unknown(v.into_static()),

     

       127
       116
        
               }

     

       128
       117
        
           }

     

       129
       118
        
       }

+24 -1

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

···

       64
       64
        
           ///List of rules defining who can reply to this post. If value is an empty array, no one can reply. If value is undefined, anyone can reply.

     

       65
       65
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       66
       66
        
           #[serde(borrow)]

     

       67
       67
       -
           pub allow: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       67
       67
       +
           pub allow: std::option::Option<Vec<ThreadgateAllowItem<'a>>>,

     

       68
       68
        
           pub created_at: jacquard_common::types::string::Datetime,

     

       69
       69
        
           ///List of hidden reply URIs.

     

       70
       70
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     
···

       75
       75
        
           ///Reference (AT-URI) to the post record.

     

       76
       76
        
           #[serde(borrow)]

     

       77
       77
        
           pub post: jacquard_common::types::string::AtUri<'a>,

     

       78
       78
       +
       }

     

       79
       79
       +
       

     

       80
       80
       +
       #[jacquard_derive::open_union]

     

       81
       81
       +
       #[derive(

     

       82
       82
       +
           serde::Serialize,

     

       83
       83
       +
           serde::Deserialize,

     

       84
       84
       +
           Debug,

     

       85
       85
       +
           Clone,

     

       86
       86
       +
           PartialEq,

     

       87
       87
       +
           Eq,

     

       88
       88
       +
           jacquard_derive::IntoStatic

     

       89
       89
       +
       )]

     

       90
       90
       +
       #[serde(tag = "$type")]

     

       91
       91
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       92
       92
       +
       pub enum ThreadgateAllowItem<'a> {

     

       93
       93
       +
           #[serde(rename = "app.bsky.feed.threadgate#mentionRule")]

     

       94
       94
       +
           MentionRule(Box<crate::app_bsky::feed::threadgate::MentionRule<'a>>),

     

       95
       95
       +
           #[serde(rename = "app.bsky.feed.threadgate#followerRule")]

     

       96
       96
       +
           FollowerRule(Box<crate::app_bsky::feed::threadgate::FollowerRule<'a>>),

     

       97
       97
       +
           #[serde(rename = "app.bsky.feed.threadgate#followingRule")]

     

       98
       98
       +
           FollowingRule(Box<crate::app_bsky::feed::threadgate::FollowingRule<'a>>),

     

       99
       99
       +
           #[serde(rename = "app.bsky.feed.threadgate#listRule")]

     

       100
       100
       +
           ListRule(Box<crate::app_bsky::feed::threadgate::ListRule<'a>>),

     

       78
       101
        
       }

     

       79
       102
        
       

     

       80
       103
        
       impl jacquard_common::types::collection::Collection for Threadgate<'_> {

+22 -16

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

···

       43
       43
        
           #[serde(borrow)]

     

       44
       44
        
           pub actor: std::option::Option<jacquard_common::types::string::Did<'a>>,

     

       45
       45
        
           #[serde(borrow)]

     

       46
       46
       -
           pub relationships: Vec<jacquard_common::types::value::Data<'a>>,

     

       46
       46
       +
           pub relationships: Vec<GetRelationshipsOutputRelationshipsItem<'a>>,

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       #[jacquard_derive::open_union]

     

       50
       50
       +
       #[derive(

     

       51
       51
       +
           serde::Serialize,

     

       52
       52
       +
           serde::Deserialize,

     

       53
       53
       +
           Debug,

     

       54
       54
       +
           Clone,

     

       55
       55
       +
           PartialEq,

     

       56
       56
       +
           Eq,

     

       57
       57
       +
           jacquard_derive::IntoStatic

     

       58
       58
       +
       )]

     

       59
       59
       +
       #[serde(tag = "$type")]

     

       60
       60
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       61
       61
       +
       pub enum GetRelationshipsOutputRelationshipsItem<'a> {

     

       62
       62
       +
           #[serde(rename = "app.bsky.graph.defs#relationship")]

     

       63
       63
       +
           Relationship(Box<crate::app_bsky::graph::Relationship<'a>>),

     

       64
       64
       +
           #[serde(rename = "app.bsky.graph.defs#notFoundActor")]

     

       65
       65
       +
           NotFoundActor(Box<crate::app_bsky::graph::NotFoundActor<'a>>),

     

       47
       66
        
       }

     

       48
       67
        
       

     

       49
       68
        
       #[jacquard_derive::open_union]

     
···

       55
       74
        
           PartialEq,

     

       56
       75
        
           Eq,

     

       57
       76
        
           thiserror::Error,

     

       58
       58
       -
           miette::Diagnostic

     

       77
       77
       +
           miette::Diagnostic,

     

       78
       78
       +
           jacquard_derive::IntoStatic

     

       59
       79
        
       )]

     

       60
       80
        
       #[serde(tag = "error", content = "message")]

     

       61
       81
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       76
       96
        
                       Ok(())

     

       77
       97
        
                   }

     

       78
       98
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       79
       79
       -
               }

     

       80
       80
       -
           }

     

       81
       81
       -
       }

     

       82
       82
       -
       

     

       83
       83
       -
       impl jacquard_common::IntoStatic for GetRelationshipsError<'_> {

     

       84
       84
       -
           type Output = GetRelationshipsError<'static>;

     

       85
       85
       -
           fn into_static(self) -> Self::Output {

     

       86
       86
       -
               match self {

     

       87
       87
       -
                   GetRelationshipsError::ActorNotFound(v) => {

     

       88
       88
       -
                       GetRelationshipsError::ActorNotFound(v.into_static())

     

       89
       89
       -
                   }

     

       90
       90
       -
                   GetRelationshipsError::Unknown(v) => {

     

       91
       91
       -
                       GetRelationshipsError::Unknown(v.into_static())

     

       92
       92
       -
                   }

     

       93
       99
        
               }

     

       94
       100
        
           }

     

       95
       101
        
       }

+1 -18

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

···

       32
       32
        
           >,

     

       33
       33
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       34
       34
        
           #[serde(borrow)]

     

       35
       35
       -
           pub labels: std::option::Option<ListRecordLabels<'a>>,

     

       35
       35
       +
           pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,

     

       36
       36
        
           ///Display name for list; can not be empty.

     

       37
       37
        
           #[serde(borrow)]

     

       38
       38
        
           pub name: jacquard_common::CowStr<'a>,

     

       39
       39
        
           ///Defines the purpose of the list (aka, moderation-oriented or curration-oriented)

     

       40
       40
        
           #[serde(borrow)]

     

       41
       41
        
           pub purpose: crate::app_bsky::graph::ListPurpose<'a>,

     

       42
       42
       -
       }

     

       43
       43
       -
       

     

       44
       44
       -
       #[jacquard_derive::open_union]

     

       45
       45
       -
       #[derive(

     

       46
       46
       -
           serde::Serialize,

     

       47
       47
       -
           serde::Deserialize,

     

       48
       48
       -
           Debug,

     

       49
       49
       -
           Clone,

     

       50
       50
       -
           PartialEq,

     

       51
       51
       -
           Eq,

     

       52
       52
       -
           jacquard_derive::IntoStatic

     

       53
       53
       -
       )]

     

       54
       54
       -
       #[serde(tag = "$type")]

     

       55
       55
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       56
       56
       -
       pub enum ListRecordLabels<'a> {

     

       57
       57
       -
           #[serde(rename = "com.atproto.label.defs#selfLabels")]

     

       58
       58
       -
           DefsSelfLabels(Box<crate::com_atproto::label::SelfLabels<'a>>),

     

       59
       42
        
       }

     

       60
       43
        
       

     

       61
       44
        
       impl jacquard_common::types::collection::Collection for List<'_> {

+20 -1

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

···

       38
       38
        
       #[serde(rename_all = "camelCase")]

     

       39
       39
        
       pub struct GetServicesOutput<'a> {

     

       40
       40
        
           #[serde(borrow)]

     

       41
       41
       -
           pub views: Vec<jacquard_common::types::value::Data<'a>>,

     

       41
       41
       +
           pub views: Vec<GetServicesOutputViewsItem<'a>>,

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       #[jacquard_derive::open_union]

     

       45
       45
       +
       #[derive(

     

       46
       46
       +
           serde::Serialize,

     

       47
       47
       +
           serde::Deserialize,

     

       48
       48
       +
           Debug,

     

       49
       49
       +
           Clone,

     

       50
       50
       +
           PartialEq,

     

       51
       51
       +
           Eq,

     

       52
       52
       +
           jacquard_derive::IntoStatic

     

       53
       53
       +
       )]

     

       54
       54
       +
       #[serde(tag = "$type")]

     

       55
       55
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       56
       56
       +
       pub enum GetServicesOutputViewsItem<'a> {

     

       57
       57
       +
           #[serde(rename = "app.bsky.labeler.defs#labelerView")]

     

       58
       58
       +
           LabelerView(Box<crate::app_bsky::labeler::LabelerView<'a>>),

     

       59
       59
       +
           #[serde(rename = "app.bsky.labeler.defs#labelerViewDetailed")]

     

       60
       60
       +
           LabelerViewDetailed(Box<crate::app_bsky::labeler::LabelerViewDetailed<'a>>),

     

       42
       61
        
       }

     

       43
       62
        
       

     

       44
       63
        
       ///Response type for

+1 -18

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

···

       21
       21
        
           pub created_at: jacquard_common::types::string::Datetime,

     

       22
       22
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
        
           #[serde(borrow)]

     

       24
       24
       -
           pub labels: std::option::Option<ServiceRecordLabels<'a>>,

     

       24
       24
       +
           pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,

     

       25
       25
        
           #[serde(borrow)]

     

       26
       26
        
           pub policies: crate::app_bsky::labeler::LabelerPolicies<'a>,

     

       27
       27
        
           ///The set of report reason 'codes' which are in-scope for this service to review and action. These usually align to policy categories. If not defined (distinct from empty array), all reason types are allowed.

     
···

       42
       42
        
           pub subject_types: std::option::Option<

     

       43
       43
        
               Vec<crate::com_atproto::moderation::SubjectType<'a>>,

     

       44
       44
        
           >,

     

       45
       45
       -
       }

     

       46
       46
       -
       

     

       47
       47
       -
       #[jacquard_derive::open_union]

     

       48
       48
       -
       #[derive(

     

       49
       49
       -
           serde::Serialize,

     

       50
       50
       -
           serde::Deserialize,

     

       51
       51
       -
           Debug,

     

       52
       52
       -
           Clone,

     

       53
       53
       -
           PartialEq,

     

       54
       54
       -
           Eq,

     

       55
       55
       -
           jacquard_derive::IntoStatic

     

       56
       56
       -
       )]

     

       57
       57
       -
       #[serde(tag = "$type")]

     

       58
       58
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       59
       59
       -
       pub enum ServiceRecordLabels<'a> {

     

       60
       60
       -
           #[serde(rename = "com.atproto.label.defs#selfLabels")]

     

       61
       61
       -
           DefsSelfLabels(Box<crate::com_atproto::label::SelfLabels<'a>>),

     

       62
       45
        
       }

     

       63
       46
        
       

     

       64
       47
        
       impl jacquard_common::types::collection::Collection for Service<'_> {

+22 -1

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

···

       53
       53
        
       #[serde(rename_all = "camelCase")]

     

       54
       54
        
       pub struct Facet<'a> {

     

       55
       55
        
           #[serde(borrow)]

     

       56
       56
       -
           pub features: Vec<jacquard_common::types::value::Data<'a>>,

     

       56
       56
       +
           pub features: Vec<FacetFeaturesItem<'a>>,

     

       57
       57
        
           #[serde(borrow)]

     

       58
       58
        
           pub index: crate::app_bsky::richtext::facet::ByteSlice<'a>,

     

       59
       59
       +
       }

     

       60
       60
       +
       

     

       61
       61
       +
       #[jacquard_derive::open_union]

     

       62
       62
       +
       #[derive(

     

       63
       63
       +
           serde::Serialize,

     

       64
       64
       +
           serde::Deserialize,

     

       65
       65
       +
           Debug,

     

       66
       66
       +
           Clone,

     

       67
       67
       +
           PartialEq,

     

       68
       68
       +
           Eq,

     

       69
       69
       +
           jacquard_derive::IntoStatic

     

       70
       70
       +
       )]

     

       71
       71
       +
       #[serde(tag = "$type")]

     

       72
       72
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       73
       73
       +
       pub enum FacetFeaturesItem<'a> {

     

       74
       74
       +
           #[serde(rename = "app.bsky.richtext.facet#mention")]

     

       75
       75
       +
           Mention(Box<crate::app_bsky::richtext::facet::Mention<'a>>),

     

       76
       76
       +
           #[serde(rename = "app.bsky.richtext.facet#link")]

     

       77
       77
       +
           Link(Box<crate::app_bsky::richtext::facet::Link<'a>>),

     

       78
       78
       +
           #[serde(rename = "app.bsky.richtext.facet#tag")]

     

       79
       79
       +
           Tag(Box<crate::app_bsky::richtext::facet::Tag<'a>>),

     

       59
       80
        
       }

     

       60
       81
        
       

     

       61
       82
        
       ///Facet feature for mention of another account. The text is usually a handle, including a '@' prefix, but the facet reference is a DID.

+1 -18

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

···

       85
       85
        
           #[serde(borrow)]

     

       86
       86
        
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       87
       87
        
           #[serde(borrow)]

     

       88
       88
       -
           pub value: ThreadItemRecordValue<'a>,

     

       89
       89
       -
       }

     

       90
       90
       -
       

     

       91
       91
       -
       #[jacquard_derive::open_union]

     

       92
       92
       -
       #[derive(

     

       93
       93
       -
           serde::Serialize,

     

       94
       94
       -
           serde::Deserialize,

     

       95
       95
       -
           Debug,

     

       96
       96
       -
           Clone,

     

       97
       97
       -
           PartialEq,

     

       98
       98
       -
           Eq,

     

       99
       99
       -
           jacquard_derive::IntoStatic

     

       100
       100
       -
       )]

     

       101
       101
       -
       #[serde(tag = "$type")]

     

       102
       102
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       103
       103
       -
       pub enum ThreadItemRecordValue<'a> {

     

       104
       104
       -
           #[serde(rename = "app.bsky.unspecced.defs#threadItemPost")]

     

       105
       105
       -
           DefsThreadItemPost(Box<crate::app_bsky::unspecced::ThreadItemPost<'a>>),

     

       88
       88
       +
           pub value: crate::app_bsky::unspecced::ThreadItemPost<'a>,

     

       106
       89
        
       }

+6 -6

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

···

       104
       104
        
           #[serde(borrow)]

     

       105
       105
        
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       106
       106
        
           #[serde(borrow)]

     

       107
       107
       -
           pub value: ThreadItemRecordValue<'a>,

     

       107
       107
       +
           pub value: ThreadItemValue<'a>,

     

       108
       108
        
       }

     

       109
       109
        
       

     

       110
       110
        
       #[jacquard_derive::open_union]

     
···

       119
       119
        
       )]

     

       120
       120
        
       #[serde(tag = "$type")]

     

       121
       121
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       122
       122
       -
       pub enum ThreadItemRecordValue<'a> {

     

       122
       122
       +
       pub enum ThreadItemValue<'a> {

     

       123
       123
        
           #[serde(rename = "app.bsky.unspecced.defs#threadItemPost")]

     

       124
       124
       -
           DefsThreadItemPost(Box<crate::app_bsky::unspecced::ThreadItemPost<'a>>),

     

       124
       124
       +
           ThreadItemPost(Box<crate::app_bsky::unspecced::ThreadItemPost<'a>>),

     

       125
       125
        
           #[serde(rename = "app.bsky.unspecced.defs#threadItemNoUnauthenticated")]

     

       126
       126
       -
           DefsThreadItemNoUnauthenticated(

     

       126
       126
       +
           ThreadItemNoUnauthenticated(

     

       127
       127
        
               Box<crate::app_bsky::unspecced::ThreadItemNoUnauthenticated<'a>>,

     

       128
       128
        
           ),

     

       129
       129
        
           #[serde(rename = "app.bsky.unspecced.defs#threadItemNotFound")]

     

       130
       130
       -
           DefsThreadItemNotFound(Box<crate::app_bsky::unspecced::ThreadItemNotFound<'a>>),

     

       130
       130
       +
           ThreadItemNotFound(Box<crate::app_bsky::unspecced::ThreadItemNotFound<'a>>),

     

       131
       131
        
           #[serde(rename = "app.bsky.unspecced.defs#threadItemBlocked")]

     

       132
       132
       -
           DefsThreadItemBlocked(Box<crate::app_bsky::unspecced::ThreadItemBlocked<'a>>),

     

       132
       132
       +
           ThreadItemBlocked(Box<crate::app_bsky::unspecced::ThreadItemBlocked<'a>>),

     

       133
       133
        
       }

+2 -21

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

···

       66
       66
        
           PartialEq,

     

       67
       67
        
           Eq,

     

       68
       68
        
           thiserror::Error,

     

       69
       69
       -
           miette::Diagnostic

     

       69
       69
       +
           miette::Diagnostic,

     

       70
       70
       +
           jacquard_derive::IntoStatic

     

       70
       71
        
       )]

     

       71
       72
        
       #[serde(tag = "error", content = "message")]

     

       72
       73
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       104
       105
        
                       Ok(())

     

       105
       106
        
                   }

     

       106
       107
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       107
       107
       -
               }

     

       108
       108
       -
           }

     

       109
       109
       -
       }

     

       110
       110
       -
       

     

       111
       111
       -
       impl jacquard_common::IntoStatic for InitAgeAssuranceError<'_> {

     

       112
       112
       -
           type Output = InitAgeAssuranceError<'static>;

     

       113
       113
       -
           fn into_static(self) -> Self::Output {

     

       114
       114
       -
               match self {

     

       115
       115
       -
                   InitAgeAssuranceError::InvalidEmail(v) => {

     

       116
       116
       -
                       InitAgeAssuranceError::InvalidEmail(v.into_static())

     

       117
       117
       -
                   }

     

       118
       118
       -
                   InitAgeAssuranceError::DidTooLong(v) => {

     

       119
       119
       -
                       InitAgeAssuranceError::DidTooLong(v.into_static())

     

       120
       120
       -
                   }

     

       121
       121
       -
                   InitAgeAssuranceError::InvalidInitiation(v) => {

     

       122
       122
       -
                       InitAgeAssuranceError::InvalidInitiation(v.into_static())

     

       123
       123
       -
                   }

     

       124
       124
       -
                   InitAgeAssuranceError::Unknown(v) => {

     

       125
       125
       -
                       InitAgeAssuranceError::Unknown(v.into_static())

     

       126
       126
       -
                   }

     

       127
       108
        
               }

     

       128
       109
        
           }

     

       129
       110
        
       }

+2 -15

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

···

       66
       66
        
           PartialEq,

     

       67
       67
        
           Eq,

     

       68
       68
        
           thiserror::Error,

     

       69
       69
       -
           miette::Diagnostic

     

       69
       69
       +
           miette::Diagnostic,

     

       70
       70
       +
           jacquard_derive::IntoStatic

     

       70
       71
        
       )]

     

       71
       72
        
       #[serde(tag = "error", content = "message")]

     

       72
       73
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       86
       87
        
                       Ok(())

     

       87
       88
        
                   }

     

       88
       89
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       89
       89
       -
               }

     

       90
       90
       -
           }

     

       91
       91
       -
       }

     

       92
       92
       -
       

     

       93
       93
       -
       impl jacquard_common::IntoStatic for SearchActorsSkeletonError<'_> {

     

       94
       94
       -
           type Output = SearchActorsSkeletonError<'static>;

     

       95
       95
       -
           fn into_static(self) -> Self::Output {

     

       96
       96
       -
               match self {

     

       97
       97
       -
                   SearchActorsSkeletonError::BadQueryString(v) => {

     

       98
       98
       -
                       SearchActorsSkeletonError::BadQueryString(v.into_static())

     

       99
       99
       -
                   }

     

       100
       100
       -
                   SearchActorsSkeletonError::Unknown(v) => {

     

       101
       101
       -
                       SearchActorsSkeletonError::Unknown(v.into_static())

     

       102
       102
       -
                   }

     

       103
       90
        
               }

     

       104
       91
        
           }

     

       105
       92
        
       }

+2 -15

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

···

       95
       95
        
           PartialEq,

     

       96
       96
        
           Eq,

     

       97
       97
        
           thiserror::Error,

     

       98
       98
       -
           miette::Diagnostic

     

       98
       98
       +
           miette::Diagnostic,

     

       99
       99
       +
           jacquard_derive::IntoStatic

     

       99
       100
        
       )]

     

       100
       101
        
       #[serde(tag = "error", content = "message")]

     

       101
       102
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       115
       116
        
                       Ok(())

     

       116
       117
        
                   }

     

       117
       118
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       118
       118
       -
               }

     

       119
       119
       -
           }

     

       120
       120
       -
       }

     

       121
       121
       -
       

     

       122
       122
       -
       impl jacquard_common::IntoStatic for SearchPostsSkeletonError<'_> {

     

       123
       123
       -
           type Output = SearchPostsSkeletonError<'static>;

     

       124
       124
       -
           fn into_static(self) -> Self::Output {

     

       125
       125
       -
               match self {

     

       126
       126
       -
                   SearchPostsSkeletonError::BadQueryString(v) => {

     

       127
       127
       -
                       SearchPostsSkeletonError::BadQueryString(v.into_static())

     

       128
       128
       -
                   }

     

       129
       129
       -
                   SearchPostsSkeletonError::Unknown(v) => {

     

       130
       130
       -
                       SearchPostsSkeletonError::Unknown(v.into_static())

     

       131
       131
       -
                   }

     

       132
       119
        
               }

     

       133
       120
        
           }

     

       134
       121
        
       }

+2 -15

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

···

       64
       64
        
           PartialEq,

     

       65
       65
        
           Eq,

     

       66
       66
        
           thiserror::Error,

     

       67
       67
       -
           miette::Diagnostic

     

       67
       67
       +
           miette::Diagnostic,

     

       68
       68
       +
           jacquard_derive::IntoStatic

     

       68
       69
        
       )]

     

       69
       70
        
       #[serde(tag = "error", content = "message")]

     

       70
       71
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       84
       85
        
                       Ok(())

     

       85
       86
        
                   }

     

       86
       87
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       87
       87
       -
               }

     

       88
       88
       -
           }

     

       89
       89
       -
       }

     

       90
       90
       -
       

     

       91
       91
       -
       impl jacquard_common::IntoStatic for SearchStarterPacksSkeletonError<'_> {

     

       92
       92
       -
           type Output = SearchStarterPacksSkeletonError<'static>;

     

       93
       93
       -
           fn into_static(self) -> Self::Output {

     

       94
       94
       -
               match self {

     

       95
       95
       -
                   SearchStarterPacksSkeletonError::BadQueryString(v) => {

     

       96
       96
       -
                       SearchStarterPacksSkeletonError::BadQueryString(v.into_static())

     

       97
       97
       -
                   }

     

       98
       98
       -
                   SearchStarterPacksSkeletonError::Unknown(v) => {

     

       99
       99
       -
                       SearchStarterPacksSkeletonError::Unknown(v.into_static())

     

       100
       100
       -
                   }

     

       101
       88
        
               }

     

       102
       89
        
           }

     

       103
       90
        
       }

+2 -19

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

···

       47
       47
        
           PartialEq,

     

       48
       48
        
           Eq,

     

       49
       49
        
           thiserror::Error,

     

       50
       50
       -
           miette::Diagnostic

     

       50
       50
       +
           miette::Diagnostic,

     

       51
       51
       +
           jacquard_derive::IntoStatic

     

       51
       52
        
       )]

     

       52
       53
        
       #[serde(tag = "error", content = "message")]

     

       53
       54
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       85
       86
        
                       Ok(())

     

       86
       87
        
                   }

     

       87
       88
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       88
       88
       -
               }

     

       89
       89
       -
           }

     

       90
       90
       -
       }

     

       91
       91
       -
       

     

       92
       92
       -
       impl jacquard_common::IntoStatic for UpdateEmailError<'_> {

     

       93
       93
       -
           type Output = UpdateEmailError<'static>;

     

       94
       94
       -
           fn into_static(self) -> Self::Output {

     

       95
       95
       -
               match self {

     

       96
       96
       -
                   UpdateEmailError::ExpiredToken(v) => {

     

       97
       97
       -
                       UpdateEmailError::ExpiredToken(v.into_static())

     

       98
       98
       -
                   }

     

       99
       99
       -
                   UpdateEmailError::InvalidToken(v) => {

     

       100
       100
       -
                       UpdateEmailError::InvalidToken(v.into_static())

     

       101
       101
       -
                   }

     

       102
       102
       -
                   UpdateEmailError::TokenRequired(v) => {

     

       103
       103
       -
                       UpdateEmailError::TokenRequired(v.into_static())

     

       104
       104
       -
                   }

     

       105
       105
       -
                   UpdateEmailError::Unknown(v) => UpdateEmailError::Unknown(v.into_static()),

     

       106
       89
        
               }

     

       107
       90
        
           }

     

       108
       91
        
       }

+20 -1

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

···

       327
       327
        
           pub expo_go: crate::app_ocho::plugin::ExpoGo<'a>,

     

       328
       328
        
       }

     

       329
       329
        
       

     

       330
       330
       -
       pub type Plugin<'a> = Vec<jacquard_common::types::value::Data<'a>>;

     

       330
       330
       +
       #[jacquard_derive::open_union]

     

       331
       331
       +
       #[derive(

     

       332
       332
       +
           serde::Serialize,

     

       333
       333
       +
           serde::Deserialize,

     

       334
       334
       +
           Debug,

     

       335
       335
       +
           Clone,

     

       336
       336
       +
           PartialEq,

     

       337
       337
       +
           Eq,

     

       338
       338
       +
           jacquard_derive::IntoStatic

     

       339
       339
       +
       )]

     

       340
       340
       +
       #[serde(tag = "$type")]

     

       341
       341
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       342
       342
       +
       pub enum PluginItem<'a> {

     

       343
       343
       +
           #[serde(rename = "app.ocho.plugin.defs#stringId")]

     

       344
       344
       +
           StringId(Box<crate::app_ocho::plugin::StringId<'a>>),

     

       345
       345
       +
           #[serde(rename = "app.ocho.plugin.defs#pluginConfig")]

     

       346
       346
       +
           PluginConfig(Box<crate::app_ocho::plugin::PluginConfig<'a>>),

     

       347
       347
       +
       }

     

       348
       348
       +
       

     

       349
       349
       +
       pub type Plugin<'a> = Vec<PluginItem<'a>>;

     

       331
       350
        
       pub type PluginConfig<'a> = jacquard_common::types::value::Data<'a>;

     

       332
       351
        
       ///A string identifier for a plugin, used to reference it in the app.

     

       333
       352
        
       pub type StringId<'a> = jacquard_common::CowStr<'a>;

+2 -14

crates/jacquard-api/src/app_ocho/state/get_config.rs

···

       37
       37
        
           PartialEq,

     

       38
       38
        
           Eq,

     

       39
       39
        
           thiserror::Error,

     

       40
       40
       -
           miette::Diagnostic

     

       40
       40
       +
           miette::Diagnostic,

     

       41
       41
       +
           jacquard_derive::IntoStatic

     

       41
       42
        
       )]

     

       42
       43
        
       #[serde(tag = "error", content = "message")]

     

       43
       44
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       66
       67
        
                       Ok(())

     

       67
       68
        
                   }

     

       68
       69
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       69
       69
       -
               }

     

       70
       70
       -
           }

     

       71
       71
       -
       }

     

       72
       72
       -
       

     

       73
       73
       -
       impl jacquard_common::IntoStatic for GetConfigError<'_> {

     

       74
       74
       -
           type Output = GetConfigError<'static>;

     

       75
       75
       -
           fn into_static(self) -> Self::Output {

     

       76
       76
       -
               match self {

     

       77
       77
       -
                   GetConfigError::InvalidId(v) => GetConfigError::InvalidId(v.into_static()),

     

       78
       78
       -
                   GetConfigError::InvalidServiceAuth(v) => {

     

       79
       79
       -
                       GetConfigError::InvalidServiceAuth(v.into_static())

     

       80
       80
       -
                   }

     

       81
       81
       -
                   GetConfigError::Unknown(v) => GetConfigError::Unknown(v.into_static()),

     

       82
       70
        
               }

     

       83
       71
        
           }

     

       84
       72
        
       }

+1 -14

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

···

       18
       18
        
       #[serde(rename_all = "camelCase")]

     

       19
       19
        
       pub struct Post<'a> {

     

       20
       20
        
           #[serde(borrow)]

     

       21
       21
       -
           pub blocks: PostRecordBlocks<'a>,

     

       21
       21
       +
           pub blocks: jacquard_common::types::value::Data<'a>,

     

       22
       22
        
           #[serde(borrow)]

     

       23
       23
        
           pub blog: crate::com_atproto::repo::strong_ref::StrongRef<'a>,

     

       24
       24
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     
···

       43
       43
        
           pub url: jacquard_common::types::string::Uri<'a>,

     

       44
       44
        
       }

     

       45
       45
        
       

     

       46
       46
       -
       #[jacquard_derive::open_union]

     

       47
       47
       -
       #[derive(

     

       48
       48
       -
           serde::Serialize,

     

       49
       49
       -
           serde::Deserialize,

     

       50
       50
       -
           Debug,

     

       51
       51
       -
           Clone,

     

       52
       52
       -
           PartialEq,

     

       53
       53
       -
           Eq,

     

       54
       54
       -
           jacquard_derive::IntoStatic

     

       55
       55
       -
       )]

     

       56
       56
       -
       #[serde(tag = "$type")]

     

       57
       57
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       58
       58
       -
       pub enum PostRecordBlocks<'a> {}

     

       59
       46
        
       impl jacquard_common::types::collection::Collection for Post<'_> {

     

       60
       47
        
           const NSID: &'static str = "blog.pckt.post";

     

       61
       48
        
       }

+1 -18

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

···

       42
       42
        
           ///Theme configuration as an open union; accepts blog.pckt.theme and future types.

     

       43
       43
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       44
       44
        
           #[serde(borrow)]

     

       45
       45
       -
           pub theme: std::option::Option<PublicationRecordTheme<'a>>,

     

       45
       45
       +
           pub theme: std::option::Option<crate::blog_pckt::theme::Theme<'a>>,

     

       46
       46
        
           ///Timestamp when the publication was last updated (optional)

     

       47
       47
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       48
       48
        
           pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       49
       49
       -
       }

     

       50
       50
       -
       

     

       51
       51
       -
       #[jacquard_derive::open_union]

     

       52
       52
       -
       #[derive(

     

       53
       53
       -
           serde::Serialize,

     

       54
       54
       -
           serde::Deserialize,

     

       55
       55
       -
           Debug,

     

       56
       56
       -
           Clone,

     

       57
       57
       -
           PartialEq,

     

       58
       58
       -
           Eq,

     

       59
       59
       -
           jacquard_derive::IntoStatic

     

       60
       60
       -
       )]

     

       61
       61
       -
       #[serde(tag = "$type")]

     

       62
       62
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       63
       63
       -
       pub enum PublicationRecordTheme<'a> {

     

       64
       64
       -
           #[serde(rename = "blog.pckt.theme")]

     

       65
       65
       -
           Theme(Box<crate::blog_pckt::theme::Theme<'a>>),

     

       66
       49
        
       }

     

       67
       50
        
       

     

       68
       51
        
       impl jacquard_common::types::collection::Collection for Publication<'_> {

+53 -62

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

···

       39
       39
        
           pub id: jacquard_common::CowStr<'a>,

     

       40
       40
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       41
       41
        
           #[serde(borrow)]

     

       42
       42
       -
           pub last_message: std::option::Option<ConvoViewRecordLastMessage<'a>>,

     

       42
       42
       +
           pub last_message: std::option::Option<ConvoViewLastMessage<'a>>,

     

       43
       43
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       44
       44
        
           #[serde(borrow)]

     

       45
       45
       -
           pub last_reaction: std::option::Option<ConvoViewRecordLastReaction<'a>>,

     

       45
       45
       +
           pub last_reaction: std::option::Option<

     

       46
       46
       +
               crate::chat_bsky::convo::MessageAndReactionView<'a>,

     

       47
       47
       +
           >,

     

       46
       48
        
           #[serde(borrow)]

     

       47
       49
        
           pub members: Vec<crate::chat_bsky::actor::ProfileViewBasic<'a>>,

     

       48
       50
        
           pub muted: bool,

     
···

       66
       68
        
       )]

     

       67
       69
        
       #[serde(tag = "$type")]

     

       68
       70
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       69
       69
       -
       pub enum ConvoViewRecordLastMessage<'a> {}

     

       70
       70
       -
       #[jacquard_derive::open_union]

     

       71
       71
       -
       #[derive(

     

       72
       72
       -
           serde::Serialize,

     

       73
       73
       -
           serde::Deserialize,

     

       74
       74
       -
           Debug,

     

       75
       75
       -
           Clone,

     

       76
       76
       -
           PartialEq,

     

       77
       77
       -
           Eq,

     

       78
       78
       -
           jacquard_derive::IntoStatic

     

       79
       79
       -
       )]

     

       80
       80
       -
       #[serde(tag = "$type")]

     

       81
       81
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       82
       82
       -
       pub enum ConvoViewRecordLastReaction<'a> {}

     

       71
       71
       +
       pub enum ConvoViewLastMessage<'a> {

     

       72
       72
       +
           #[serde(rename = "chat.bsky.convo.defs#messageView")]

     

       73
       73
       +
           MessageView(Box<crate::chat_bsky::convo::MessageView<'a>>),

     

       74
       74
       +
           #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]

     

       75
       75
       +
           DeletedMessageView(Box<crate::chat_bsky::convo::DeletedMessageView<'a>>),

     

       76
       76
       +
       }

     

       77
       77
       +
       

     

       83
       78
        
       #[jacquard_derive::lexicon]

     

       84
       79
        
       #[derive(

     

       85
       80
        
           serde::Serialize,

     
···

       134
       129
        
           #[serde(borrow)]

     

       135
       130
        
           pub convo_id: jacquard_common::CowStr<'a>,

     

       136
       131
        
           #[serde(borrow)]

     

       137
       137
       -
           pub message: LogAddReactionRecordMessage<'a>,

     

       132
       132
       +
           pub message: LogAddReactionMessage<'a>,

     

       138
       133
        
           #[serde(borrow)]

     

       139
       134
        
           pub reaction: crate::chat_bsky::convo::ReactionView<'a>,

     

       140
       135
        
           #[serde(borrow)]

     
···

       153
       148
        
       )]

     

       154
       149
        
       #[serde(tag = "$type")]

     

       155
       150
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       156
       156
       -
       pub enum LogAddReactionRecordMessage<'a> {}

     

       151
       151
       +
       pub enum LogAddReactionMessage<'a> {

     

       152
       152
       +
           #[serde(rename = "chat.bsky.convo.defs#messageView")]

     

       153
       153
       +
           MessageView(Box<crate::chat_bsky::convo::MessageView<'a>>),

     

       154
       154
       +
           #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]

     

       155
       155
       +
           DeletedMessageView(Box<crate::chat_bsky::convo::DeletedMessageView<'a>>),

     

       156
       156
       +
       }

     

       157
       157
       +
       

     

       157
       158
        
       #[jacquard_derive::lexicon]

     

       158
       159
        
       #[derive(

     

       159
       160
        
           serde::Serialize,

     
···

       187
       188
        
           #[serde(borrow)]

     

       188
       189
        
           pub convo_id: jacquard_common::CowStr<'a>,

     

       189
       190
        
           #[serde(borrow)]

     

       190
       190
       -
           pub message: LogCreateMessageRecordMessage<'a>,

     

       191
       191
       +
           pub message: LogCreateMessageMessage<'a>,

     

       191
       192
        
           #[serde(borrow)]

     

       192
       193
        
           pub rev: jacquard_common::CowStr<'a>,

     

       193
       194
        
       }

     
···

       204
       205
        
       )]

     

       205
       206
        
       #[serde(tag = "$type")]

     

       206
       207
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       207
       207
       -
       pub enum LogCreateMessageRecordMessage<'a> {}

     

       208
       208
       +
       pub enum LogCreateMessageMessage<'a> {

     

       209
       209
       +
           #[serde(rename = "chat.bsky.convo.defs#messageView")]

     

       210
       210
       +
           MessageView(Box<crate::chat_bsky::convo::MessageView<'a>>),

     

       211
       211
       +
           #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]

     

       212
       212
       +
           DeletedMessageView(Box<crate::chat_bsky::convo::DeletedMessageView<'a>>),

     

       213
       213
       +
       }

     

       214
       214
       +
       

     

       208
       215
        
       #[jacquard_derive::lexicon]

     

       209
       216
        
       #[derive(

     

       210
       217
        
           serde::Serialize,

     
···

       220
       227
        
           #[serde(borrow)]

     

       221
       228
        
           pub convo_id: jacquard_common::CowStr<'a>,

     

       222
       229
        
           #[serde(borrow)]

     

       223
       223
       -
           pub message: LogDeleteMessageRecordMessage<'a>,

     

       230
       230
       +
           pub message: LogDeleteMessageMessage<'a>,

     

       224
       231
        
           #[serde(borrow)]

     

       225
       232
        
           pub rev: jacquard_common::CowStr<'a>,

     

       226
       233
        
       }

     
···

       237
       244
        
       )]

     

       238
       245
        
       #[serde(tag = "$type")]

     

       239
       246
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       240
       240
       -
       pub enum LogDeleteMessageRecordMessage<'a> {}

     

       247
       247
       +
       pub enum LogDeleteMessageMessage<'a> {

     

       248
       248
       +
           #[serde(rename = "chat.bsky.convo.defs#messageView")]

     

       249
       249
       +
           MessageView(Box<crate::chat_bsky::convo::MessageView<'a>>),

     

       250
       250
       +
           #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]

     

       251
       251
       +
           DeletedMessageView(Box<crate::chat_bsky::convo::DeletedMessageView<'a>>),

     

       252
       252
       +
       }

     

       253
       253
       +
       

     

       241
       254
        
       #[jacquard_derive::lexicon]

     

       242
       255
        
       #[derive(

     

       243
       256
        
           serde::Serialize,

     
···

       289
       302
        
           #[serde(borrow)]

     

       290
       303
        
           pub convo_id: jacquard_common::CowStr<'a>,

     

       291
       304
        
           #[serde(borrow)]

     

       292
       292
       -
           pub message: LogReadMessageRecordMessage<'a>,

     

       305
       305
       +
           pub message: LogReadMessageMessage<'a>,

     

       293
       306
        
           #[serde(borrow)]

     

       294
       307
        
           pub rev: jacquard_common::CowStr<'a>,

     

       295
       308
        
       }

     
···

       306
       319
        
       )]

     

       307
       320
        
       #[serde(tag = "$type")]

     

       308
       321
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       309
       309
       -
       pub enum LogReadMessageRecordMessage<'a> {}

     

       322
       322
       +
       pub enum LogReadMessageMessage<'a> {

     

       323
       323
       +
           #[serde(rename = "chat.bsky.convo.defs#messageView")]

     

       324
       324
       +
           MessageView(Box<crate::chat_bsky::convo::MessageView<'a>>),

     

       325
       325
       +
           #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]

     

       326
       326
       +
           DeletedMessageView(Box<crate::chat_bsky::convo::DeletedMessageView<'a>>),

     

       327
       327
       +
       }

     

       328
       328
       +
       

     

       310
       329
        
       #[jacquard_derive::lexicon]

     

       311
       330
        
       #[derive(

     

       312
       331
        
           serde::Serialize,

     
···

       322
       341
        
           #[serde(borrow)]

     

       323
       342
        
           pub convo_id: jacquard_common::CowStr<'a>,

     

       324
       343
        
           #[serde(borrow)]

     

       325
       325
       -
           pub message: LogRemoveReactionRecordMessage<'a>,

     

       344
       344
       +
           pub message: LogRemoveReactionMessage<'a>,

     

       326
       345
        
           #[serde(borrow)]

     

       327
       346
        
           pub reaction: crate::chat_bsky::convo::ReactionView<'a>,

     

       328
       347
        
           #[serde(borrow)]

     
···

       341
       360
        
       )]

     

       342
       361
        
       #[serde(tag = "$type")]

     

       343
       362
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       344
       344
       -
       pub enum LogRemoveReactionRecordMessage<'a> {}

     

       363
       363
       +
       pub enum LogRemoveReactionMessage<'a> {

     

       364
       364
       +
           #[serde(rename = "chat.bsky.convo.defs#messageView")]

     

       365
       365
       +
           MessageView(Box<crate::chat_bsky::convo::MessageView<'a>>),

     

       366
       366
       +
           #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]

     

       367
       367
       +
           DeletedMessageView(Box<crate::chat_bsky::convo::DeletedMessageView<'a>>),

     

       368
       368
       +
       }

     

       369
       369
       +
       

     

       345
       370
        
       #[jacquard_derive::lexicon]

     

       346
       371
        
       #[derive(

     

       347
       372
        
           serde::Serialize,

     
···

       392
       417
        
       pub struct MessageInput<'a> {

     

       393
       418
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       394
       419
        
           #[serde(borrow)]

     

       395
       395
       -
           pub embed: std::option::Option<MessageInputRecordEmbed<'a>>,

     

       420
       420
       +
           pub embed: std::option::Option<crate::app_bsky::embed::record::Record<'a>>,

     

       396
       421
        
           ///Annotations of text (mentions, URLs, hashtags, etc)

     

       397
       422
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       398
       423
        
           #[serde(borrow)]

     
···

       401
       426
        
           pub text: jacquard_common::CowStr<'a>,

     

       402
       427
        
       }

     

       403
       428
        
       

     

       404
       404
       -
       #[jacquard_derive::open_union]

     

       405
       405
       -
       #[derive(

     

       406
       406
       -
           serde::Serialize,

     

       407
       407
       -
           serde::Deserialize,

     

       408
       408
       -
           Debug,

     

       409
       409
       -
           Clone,

     

       410
       410
       -
           PartialEq,

     

       411
       411
       -
           Eq,

     

       412
       412
       -
           jacquard_derive::IntoStatic

     

       413
       413
       -
       )]

     

       414
       414
       -
       #[serde(tag = "$type")]

     

       415
       415
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       416
       416
       -
       pub enum MessageInputRecordEmbed<'a> {

     

       417
       417
       -
           #[serde(rename = "app.bsky.embed.record")]

     

       418
       418
       -
           Record(Box<crate::app_bsky::embed::record::Record<'a>>),

     

       419
       419
       -
       }

     

       420
       420
       -
       

     

       421
       429
        
       #[jacquard_derive::lexicon]

     

       422
       430
        
       #[derive(

     

       423
       431
        
           serde::Serialize,

     
···

       452
       460
        
       pub struct MessageView<'a> {

     

       453
       461
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       454
       462
        
           #[serde(borrow)]

     

       455
       455
       -
           pub embed: std::option::Option<MessageViewRecordEmbed<'a>>,

     

       463
       463
       +
           pub embed: std::option::Option<crate::app_bsky::embed::record::View<'a>>,

     

       456
       464
        
           ///Annotations of text (mentions, URLs, hashtags, etc)

     

       457
       465
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       458
       466
        
           #[serde(borrow)]

     
···

       470
       478
        
           pub sent_at: jacquard_common::types::string::Datetime,

     

       471
       479
        
           #[serde(borrow)]

     

       472
       480
        
           pub text: jacquard_common::CowStr<'a>,

     

       473
       473
       -
       }

     

       474
       474
       -
       

     

       475
       475
       -
       #[jacquard_derive::open_union]

     

       476
       476
       -
       #[derive(

     

       477
       477
       -
           serde::Serialize,

     

       478
       478
       -
           serde::Deserialize,

     

       479
       479
       -
           Debug,

     

       480
       480
       -
           Clone,

     

       481
       481
       -
           PartialEq,

     

       482
       482
       -
           Eq,

     

       483
       483
       -
           jacquard_derive::IntoStatic

     

       484
       484
       -
       )]

     

       485
       485
       -
       #[serde(tag = "$type")]

     

       486
       486
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       487
       487
       -
       pub enum MessageViewRecordEmbed<'a> {

     

       488
       488
       -
           #[serde(rename = "app.bsky.embed.record#view")]

     

       489
       489
       -
           RecordView(Box<crate::app_bsky::embed::record::View<'a>>),

     

       490
       481
        
       }

     

       491
       482
        
       

     

       492
       483
        
       #[jacquard_derive::lexicon]

+2 -19

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

···

       62
       62
        
           PartialEq,

     

       63
       63
        
           Eq,

     

       64
       64
        
           thiserror::Error,

     

       65
       65
       -
           miette::Diagnostic

     

       65
       65
       +
           miette::Diagnostic,

     

       66
       66
       +
           jacquard_derive::IntoStatic

     

       66
       67
        
       )]

     

       67
       68
        
       #[serde(tag = "error", content = "message")]

     

       68
       69
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       103
       104
        
                       Ok(())

     

       104
       105
        
                   }

     

       105
       106
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       106
       106
       -
               }

     

       107
       107
       -
           }

     

       108
       108
       -
       }

     

       109
       109
       -
       

     

       110
       110
       -
       impl jacquard_common::IntoStatic for AddReactionError<'_> {

     

       111
       111
       -
           type Output = AddReactionError<'static>;

     

       112
       112
       -
           fn into_static(self) -> Self::Output {

     

       113
       113
       -
               match self {

     

       114
       114
       -
                   AddReactionError::ReactionMessageDeleted(v) => {

     

       115
       115
       -
                       AddReactionError::ReactionMessageDeleted(v.into_static())

     

       116
       116
       -
                   }

     

       117
       117
       -
                   AddReactionError::ReactionLimitReached(v) => {

     

       118
       118
       -
                       AddReactionError::ReactionLimitReached(v.into_static())

     

       119
       119
       -
                   }

     

       120
       120
       -
                   AddReactionError::ReactionInvalidValue(v) => {

     

       121
       121
       -
                       AddReactionError::ReactionInvalidValue(v.into_static())

     

       122
       122
       -
                   }

     

       123
       123
       -
                   AddReactionError::Unknown(v) => AddReactionError::Unknown(v.into_static()),

     

       124
       107
        
               }

     

       125
       108
        
           }

     

       126
       109
        
       }

+36 -1

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

···

       40
       40
        
           #[serde(borrow)]

     

       41
       41
        
           pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,

     

       42
       42
        
           #[serde(borrow)]

     

       43
       43
       -
           pub logs: Vec<jacquard_common::types::value::Data<'a>>,

     

       43
       43
       +
           pub logs: Vec<GetLogOutputLogsItem<'a>>,

     

       44
       44
       +
       }

     

       45
       45
       +
       

     

       46
       46
       +
       #[jacquard_derive::open_union]

     

       47
       47
       +
       #[derive(

     

       48
       48
       +
           serde::Serialize,

     

       49
       49
       +
           serde::Deserialize,

     

       50
       50
       +
           Debug,

     

       51
       51
       +
           Clone,

     

       52
       52
       +
           PartialEq,

     

       53
       53
       +
           Eq,

     

       54
       54
       +
           jacquard_derive::IntoStatic

     

       55
       55
       +
       )]

     

       56
       56
       +
       #[serde(tag = "$type")]

     

       57
       57
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       58
       58
       +
       pub enum GetLogOutputLogsItem<'a> {

     

       59
       59
       +
           #[serde(rename = "chat.bsky.convo.defs#logBeginConvo")]

     

       60
       60
       +
           LogBeginConvo(Box<crate::chat_bsky::convo::LogBeginConvo<'a>>),

     

       61
       61
       +
           #[serde(rename = "chat.bsky.convo.defs#logAcceptConvo")]

     

       62
       62
       +
           LogAcceptConvo(Box<crate::chat_bsky::convo::LogAcceptConvo<'a>>),

     

       63
       63
       +
           #[serde(rename = "chat.bsky.convo.defs#logLeaveConvo")]

     

       64
       64
       +
           LogLeaveConvo(Box<crate::chat_bsky::convo::LogLeaveConvo<'a>>),

     

       65
       65
       +
           #[serde(rename = "chat.bsky.convo.defs#logMuteConvo")]

     

       66
       66
       +
           LogMuteConvo(Box<crate::chat_bsky::convo::LogMuteConvo<'a>>),

     

       67
       67
       +
           #[serde(rename = "chat.bsky.convo.defs#logUnmuteConvo")]

     

       68
       68
       +
           LogUnmuteConvo(Box<crate::chat_bsky::convo::LogUnmuteConvo<'a>>),

     

       69
       69
       +
           #[serde(rename = "chat.bsky.convo.defs#logCreateMessage")]

     

       70
       70
       +
           LogCreateMessage(Box<crate::chat_bsky::convo::LogCreateMessage<'a>>),

     

       71
       71
       +
           #[serde(rename = "chat.bsky.convo.defs#logDeleteMessage")]

     

       72
       72
       +
           LogDeleteMessage(Box<crate::chat_bsky::convo::LogDeleteMessage<'a>>),

     

       73
       73
       +
           #[serde(rename = "chat.bsky.convo.defs#logReadMessage")]

     

       74
       74
       +
           LogReadMessage(Box<crate::chat_bsky::convo::LogReadMessage<'a>>),

     

       75
       75
       +
           #[serde(rename = "chat.bsky.convo.defs#logAddReaction")]

     

       76
       76
       +
           LogAddReaction(Box<crate::chat_bsky::convo::LogAddReaction<'a>>),

     

       77
       77
       +
           #[serde(rename = "chat.bsky.convo.defs#logRemoveReaction")]

     

       78
       78
       +
           LogRemoveReaction(Box<crate::chat_bsky::convo::LogRemoveReaction<'a>>),

     

       44
       79
        
       }

     

       45
       80
        
       

     

       46
       81
        
       ///Response type for

+20 -1

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

···

       46
       46
        
           #[serde(borrow)]

     

       47
       47
        
           pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,

     

       48
       48
        
           #[serde(borrow)]

     

       49
       49
       -
           pub messages: Vec<jacquard_common::types::value::Data<'a>>,

     

       49
       49
       +
           pub messages: Vec<GetMessagesOutputMessagesItem<'a>>,

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       #[jacquard_derive::open_union]

     

       53
       53
       +
       #[derive(

     

       54
       54
       +
           serde::Serialize,

     

       55
       55
       +
           serde::Deserialize,

     

       56
       56
       +
           Debug,

     

       57
       57
       +
           Clone,

     

       58
       58
       +
           PartialEq,

     

       59
       59
       +
           Eq,

     

       60
       60
       +
           jacquard_derive::IntoStatic

     

       61
       61
       +
       )]

     

       62
       62
       +
       #[serde(tag = "$type")]

     

       63
       63
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       64
       64
       +
       pub enum GetMessagesOutputMessagesItem<'a> {

     

       65
       65
       +
           #[serde(rename = "chat.bsky.convo.defs#messageView")]

     

       66
       66
       +
           MessageView(Box<crate::chat_bsky::convo::MessageView<'a>>),

     

       67
       67
       +
           #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]

     

       68
       68
       +
           DeletedMessageView(Box<crate::chat_bsky::convo::DeletedMessageView<'a>>),

     

       50
       69
        
       }

     

       51
       70
        
       

     

       52
       71
        
       ///Response type for

+2 -18

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

···

       62
       62
        
           PartialEq,

     

       63
       63
        
           Eq,

     

       64
       64
        
           thiserror::Error,

     

       65
       65
       -
           miette::Diagnostic

     

       65
       65
       +
           miette::Diagnostic,

     

       66
       66
       +
           jacquard_derive::IntoStatic

     

       66
       67
        
       )]

     

       67
       68
        
       #[serde(tag = "error", content = "message")]

     

       68
       69
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       93
       94
        
                       Ok(())

     

       94
       95
        
                   }

     

       95
       96
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       96
       96
       -
               }

     

       97
       97
       -
           }

     

       98
       98
       -
       }

     

       99
       99
       -
       

     

       100
       100
       -
       impl jacquard_common::IntoStatic for RemoveReactionError<'_> {

     

       101
       101
       -
           type Output = RemoveReactionError<'static>;

     

       102
       102
       -
           fn into_static(self) -> Self::Output {

     

       103
       103
       -
               match self {

     

       104
       104
       -
                   RemoveReactionError::ReactionMessageDeleted(v) => {

     

       105
       105
       -
                       RemoveReactionError::ReactionMessageDeleted(v.into_static())

     

       106
       106
       -
                   }

     

       107
       107
       -
                   RemoveReactionError::ReactionInvalidValue(v) => {

     

       108
       108
       -
                       RemoveReactionError::ReactionInvalidValue(v.into_static())

     

       109
       109
       -
                   }

     

       110
       110
       -
                   RemoveReactionError::Unknown(v) => {

     

       111
       111
       -
                       RemoveReactionError::Unknown(v.into_static())

     

       112
       112
       -
                   }

     

       113
       97
        
               }

     

       114
       98
        
           }

     

       115
       99
        
       }

+20 -1

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

···

       46
       46
        
       #[serde(rename_all = "camelCase")]

     

       47
       47
        
       pub struct GetMessageContextOutput<'a> {

     

       48
       48
        
           #[serde(borrow)]

     

       49
       49
       -
           pub messages: Vec<jacquard_common::types::value::Data<'a>>,

     

       49
       49
       +
           pub messages: Vec<GetMessageContextOutputMessagesItem<'a>>,

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       #[jacquard_derive::open_union]

     

       53
       53
       +
       #[derive(

     

       54
       54
       +
           serde::Serialize,

     

       55
       55
       +
           serde::Deserialize,

     

       56
       56
       +
           Debug,

     

       57
       57
       +
           Clone,

     

       58
       58
       +
           PartialEq,

     

       59
       59
       +
           Eq,

     

       60
       60
       +
           jacquard_derive::IntoStatic

     

       61
       61
       +
       )]

     

       62
       62
       +
       #[serde(tag = "$type")]

     

       63
       63
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       64
       64
       +
       pub enum GetMessageContextOutputMessagesItem<'a> {

     

       65
       65
       +
           #[serde(rename = "chat.bsky.convo.defs#messageView")]

     

       66
       66
       +
           MessageView(Box<crate::chat_bsky::convo::MessageView<'a>>),

     

       67
       67
       +
           #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]

     

       68
       68
       +
           DeletedMessageView(Box<crate::chat_bsky::convo::DeletedMessageView<'a>>),

     

       50
       69
        
       }

     

       51
       70
        
       

     

       52
       71
        
       ///Response type for

+4 -4

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

···

       45
       45
        
           #[serde(borrow)]

     

       46
       46
        
           pub deactivated: std::option::Option<crate::com_atproto::admin::StatusAttr<'a>>,

     

       47
       47
        
           #[serde(borrow)]

     

       48
       48
       -
           pub subject: GetSubjectStatusOutputRecordSubject<'a>,

     

       48
       48
       +
           pub subject: GetSubjectStatusOutputSubject<'a>,

     

       49
       49
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       50
       50
        
           #[serde(borrow)]

     

       51
       51
        
           pub takedown: std::option::Option<crate::com_atproto::admin::StatusAttr<'a>>,

     
···

       63
       63
        
       )]

     

       64
       64
        
       #[serde(tag = "$type")]

     

       65
       65
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       66
       66
       -
       pub enum GetSubjectStatusOutputRecordSubject<'a> {

     

       66
       66
       +
       pub enum GetSubjectStatusOutputSubject<'a> {

     

       67
       67
        
           #[serde(rename = "com.atproto.admin.defs#repoRef")]

     

       68
       68
       -
           DefsRepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       68
       68
       +
           RepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       69
       69
        
           #[serde(rename = "com.atproto.repo.strongRef")]

     

       70
       70
        
           StrongRef(Box<crate::com_atproto::repo::strong_ref::StrongRef<'a>>),

     

       71
       71
        
           #[serde(rename = "com.atproto.admin.defs#repoBlobRef")]

     

       72
       72
       -
           DefsRepoBlobRef(Box<crate::com_atproto::admin::RepoBlobRef<'a>>),

     

       72
       72
       +
           RepoBlobRef(Box<crate::com_atproto::admin::RepoBlobRef<'a>>),

     

       73
       73
        
       }

     

       74
       74
        
       

     

       75
       75
        
       ///Response type for

+8 -8

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

···

       23
       23
        
           #[serde(borrow)]

     

       24
       24
        
           pub deactivated: std::option::Option<crate::com_atproto::admin::StatusAttr<'a>>,

     

       25
       25
        
           #[serde(borrow)]

     

       26
       26
       -
           pub subject: UpdateSubjectStatusRecordSubject<'a>,

     

       26
       26
       +
           pub subject: UpdateSubjectStatusSubject<'a>,

     

       27
       27
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
        
           #[serde(borrow)]

     

       29
       29
        
           pub takedown: std::option::Option<crate::com_atproto::admin::StatusAttr<'a>>,

     
···

       48
       48
        
       )]

     

       49
       49
        
       #[serde(tag = "$type")]

     

       50
       50
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       51
       51
       -
       pub enum UpdateSubjectStatusRecordSubject<'a> {

     

       51
       51
       +
       pub enum UpdateSubjectStatusSubject<'a> {

     

       52
       52
        
           #[serde(rename = "com.atproto.admin.defs#repoRef")]

     

       53
       53
       -
           DefsRepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       53
       53
       +
           RepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       54
       54
        
           #[serde(rename = "com.atproto.repo.strongRef")]

     

       55
       55
        
           StrongRef(Box<crate::com_atproto::repo::strong_ref::StrongRef<'a>>),

     

       56
       56
        
           #[serde(rename = "com.atproto.admin.defs#repoBlobRef")]

     

       57
       57
       -
           DefsRepoBlobRef(Box<crate::com_atproto::admin::RepoBlobRef<'a>>),

     

       57
       57
       +
           RepoBlobRef(Box<crate::com_atproto::admin::RepoBlobRef<'a>>),

     

       58
       58
        
       }

     

       59
       59
        
       

     

       60
       60
        
       #[jacquard_derive::lexicon]

     
···

       70
       70
        
       #[serde(rename_all = "camelCase")]

     

       71
       71
        
       pub struct UpdateSubjectStatusOutput<'a> {

     

       72
       72
        
           #[serde(borrow)]

     

       73
       73
       -
           pub subject: UpdateSubjectStatusOutputRecordSubject<'a>,

     

       73
       73
       +
           pub subject: UpdateSubjectStatusOutputSubject<'a>,

     

       74
       74
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       75
       75
        
           #[serde(borrow)]

     

       76
       76
        
           pub takedown: std::option::Option<crate::com_atproto::admin::StatusAttr<'a>>,

     
···

       88
       88
        
       )]

     

       89
       89
        
       #[serde(tag = "$type")]

     

       90
       90
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       91
       91
       -
       pub enum UpdateSubjectStatusOutputRecordSubject<'a> {

     

       91
       91
       +
       pub enum UpdateSubjectStatusOutputSubject<'a> {

     

       92
       92
        
           #[serde(rename = "com.atproto.admin.defs#repoRef")]

     

       93
       93
       -
           DefsRepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       93
       93
       +
           RepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       94
       94
        
           #[serde(rename = "com.atproto.repo.strongRef")]

     

       95
       95
        
           StrongRef(Box<crate::com_atproto::repo::strong_ref::StrongRef<'a>>),

     

       96
       96
        
           #[serde(rename = "com.atproto.admin.defs#repoBlobRef")]

     

       97
       97
       -
           DefsRepoBlobRef(Box<crate::com_atproto::admin::RepoBlobRef<'a>>),

     

       97
       97
       +
           RepoBlobRef(Box<crate::com_atproto::admin::RepoBlobRef<'a>>),

     

       98
       98
        
       }

     

       99
       99
        
       

     

       100
       100
        
       ///Response type for

+2 -21

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

···

       56
       56
        
           PartialEq,

     

       57
       57
        
           Eq,

     

       58
       58
        
           thiserror::Error,

     

       59
       59
       -
           miette::Diagnostic

     

       59
       59
       +
           miette::Diagnostic,

     

       60
       60
       +
           jacquard_derive::IntoStatic

     

       60
       61
        
       )]

     

       61
       62
        
       #[serde(tag = "error", content = "message")]

     

       62
       63
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       97
       98
        
                       Ok(())

     

       98
       99
        
                   }

     

       99
       100
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       100
       100
       -
               }

     

       101
       101
       -
           }

     

       102
       102
       -
       }

     

       103
       103
       -
       

     

       104
       104
       -
       impl jacquard_common::IntoStatic for RefreshIdentityError<'_> {

     

       105
       105
       -
           type Output = RefreshIdentityError<'static>;

     

       106
       106
       -
           fn into_static(self) -> Self::Output {

     

       107
       107
       -
               match self {

     

       108
       108
       -
                   RefreshIdentityError::HandleNotFound(v) => {

     

       109
       109
       -
                       RefreshIdentityError::HandleNotFound(v.into_static())

     

       110
       110
       -
                   }

     

       111
       111
       -
                   RefreshIdentityError::DidNotFound(v) => {

     

       112
       112
       -
                       RefreshIdentityError::DidNotFound(v.into_static())

     

       113
       113
       -
                   }

     

       114
       114
       -
                   RefreshIdentityError::DidDeactivated(v) => {

     

       115
       115
       -
                       RefreshIdentityError::DidDeactivated(v.into_static())

     

       116
       116
       -
                   }

     

       117
       117
       -
                   RefreshIdentityError::Unknown(v) => {

     

       118
       118
       -
                       RefreshIdentityError::Unknown(v.into_static())

     

       119
       119
       -
                   }

     

       120
       101
        
               }

     

       121
       102
        
           }

     

       122
       103
        
       }

+2 -16

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

···

       48
       48
        
           PartialEq,

     

       49
       49
        
           Eq,

     

       50
       50
        
           thiserror::Error,

     

       51
       51
       -
           miette::Diagnostic

     

       51
       51
       +
           miette::Diagnostic,

     

       52
       52
       +
           jacquard_derive::IntoStatic

     

       52
       53
        
       )]

     

       53
       54
        
       #[serde(tag = "error", content = "message")]

     

       54
       55
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       79
       80
        
                       Ok(())

     

       80
       81
        
                   }

     

       81
       82
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       82
       82
       -
               }

     

       83
       83
       -
           }

     

       84
       84
       -
       }

     

       85
       85
       -
       

     

       86
       86
       -
       impl jacquard_common::IntoStatic for ResolveDidError<'_> {

     

       87
       87
       -
           type Output = ResolveDidError<'static>;

     

       88
       88
       -
           fn into_static(self) -> Self::Output {

     

       89
       89
       -
               match self {

     

       90
       90
       -
                   ResolveDidError::DidNotFound(v) => {

     

       91
       91
       -
                       ResolveDidError::DidNotFound(v.into_static())

     

       92
       92
       -
                   }

     

       93
       93
       -
                   ResolveDidError::DidDeactivated(v) => {

     

       94
       94
       -
                       ResolveDidError::DidDeactivated(v.into_static())

     

       95
       95
       -
                   }

     

       96
       96
       -
                   ResolveDidError::Unknown(v) => ResolveDidError::Unknown(v.into_static()),

     

       97
       83
        
               }

     

       98
       84
        
           }

     

       99
       85
        
       }

+2 -15

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

···

       47
       47
        
           PartialEq,

     

       48
       48
        
           Eq,

     

       49
       49
        
           thiserror::Error,

     

       50
       50
       -
           miette::Diagnostic

     

       50
       50
       +
           miette::Diagnostic,

     

       51
       51
       +
           jacquard_derive::IntoStatic

     

       51
       52
        
       )]

     

       52
       53
        
       #[serde(tag = "error", content = "message")]

     

       53
       54
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       68
       69
        
                       Ok(())

     

       69
       70
        
                   }

     

       70
       71
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       71
       71
       -
               }

     

       72
       72
       -
           }

     

       73
       73
       -
       }

     

       74
       74
       -
       

     

       75
       75
       -
       impl jacquard_common::IntoStatic for ResolveHandleError<'_> {

     

       76
       76
       -
           type Output = ResolveHandleError<'static>;

     

       77
       77
       -
           fn into_static(self) -> Self::Output {

     

       78
       78
       -
               match self {

     

       79
       79
       -
                   ResolveHandleError::HandleNotFound(v) => {

     

       80
       80
       -
                       ResolveHandleError::HandleNotFound(v.into_static())

     

       81
       81
       -
                   }

     

       82
       82
       -
                   ResolveHandleError::Unknown(v) => {

     

       83
       83
       -
                       ResolveHandleError::Unknown(v.into_static())

     

       84
       84
       -
                   }

     

       85
       72
        
               }

     

       86
       73
        
           }

     

       87
       74
        
       }

+2 -21

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

···

       48
       48
        
           PartialEq,

     

       49
       49
        
           Eq,

     

       50
       50
        
           thiserror::Error,

     

       51
       51
       -
           miette::Diagnostic

     

       51
       51
       +
           miette::Diagnostic,

     

       52
       52
       +
           jacquard_derive::IntoStatic

     

       52
       53
        
       )]

     

       53
       54
        
       #[serde(tag = "error", content = "message")]

     

       54
       55
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       89
       90
        
                       Ok(())

     

       90
       91
        
                   }

     

       91
       92
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       92
       92
       -
               }

     

       93
       93
       -
           }

     

       94
       94
       -
       }

     

       95
       95
       -
       

     

       96
       96
       -
       impl jacquard_common::IntoStatic for ResolveIdentityError<'_> {

     

       97
       97
       -
           type Output = ResolveIdentityError<'static>;

     

       98
       98
       -
           fn into_static(self) -> Self::Output {

     

       99
       99
       -
               match self {

     

       100
       100
       -
                   ResolveIdentityError::HandleNotFound(v) => {

     

       101
       101
       -
                       ResolveIdentityError::HandleNotFound(v.into_static())

     

       102
       102
       -
                   }

     

       103
       103
       -
                   ResolveIdentityError::DidNotFound(v) => {

     

       104
       104
       -
                       ResolveIdentityError::DidNotFound(v.into_static())

     

       105
       105
       -
                   }

     

       106
       106
       -
                   ResolveIdentityError::DidDeactivated(v) => {

     

       107
       107
       -
                       ResolveIdentityError::DidDeactivated(v.into_static())

     

       108
       108
       -
                   }

     

       109
       109
       -
                   ResolveIdentityError::Unknown(v) => {

     

       110
       110
       -
                       ResolveIdentityError::Unknown(v.into_static())

     

       111
       111
       -
                   }

     

       112
       93
        
               }

     

       113
       94
        
           }

     

       114
       95
        
       }

+2 -15

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

···

       86
       86
        
           PartialEq,

     

       87
       87
        
           Eq,

     

       88
       88
        
           thiserror::Error,

     

       89
       89
       -
           miette::Diagnostic

     

       89
       89
       +
           miette::Diagnostic,

     

       90
       90
       +
           jacquard_derive::IntoStatic

     

       90
       91
        
       )]

     

       91
       92
        
       #[serde(tag = "error", content = "message")]

     

       92
       93
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       106
       107
        
                       Ok(())

     

       107
       108
        
                   }

     

       108
       109
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       109
       109
       -
               }

     

       110
       110
       -
           }

     

       111
       111
       -
       }

     

       112
       112
       -
       

     

       113
       113
       -
       impl jacquard_common::IntoStatic for SubscribeLabelsError<'_> {

     

       114
       114
       -
           type Output = SubscribeLabelsError<'static>;

     

       115
       115
       -
           fn into_static(self) -> Self::Output {

     

       116
       116
       -
               match self {

     

       117
       117
       -
                   SubscribeLabelsError::FutureCursor(v) => {

     

       118
       118
       -
                       SubscribeLabelsError::FutureCursor(v.into_static())

     

       119
       119
       -
                   }

     

       120
       120
       -
                   SubscribeLabelsError::Unknown(v) => {

     

       121
       121
       -
                       SubscribeLabelsError::Unknown(v.into_static())

     

       122
       122
       -
                   }

     

       123
       110
        
               }

     

       124
       111
        
           }

     

       125
       112
        
       }

+6 -6

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

···

       31
       31
        
           #[serde(borrow)]

     

       32
       32
        
           pub reason_type: crate::com_atproto::moderation::ReasonType<'a>,

     

       33
       33
        
           #[serde(borrow)]

     

       34
       34
       -
           pub subject: CreateReportRecordSubject<'a>,

     

       34
       34
       +
           pub subject: CreateReportSubject<'a>,

     

       35
       35
        
           #[serde(flatten)]

     

       36
       36
        
           #[serde(borrow)]

     

       37
       37
        
           #[builder(default)]

     
···

       53
       53
        
       )]

     

       54
       54
        
       #[serde(tag = "$type")]

     

       55
       55
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       56
       56
       -
       pub enum CreateReportRecordSubject<'a> {

     

       56
       56
       +
       pub enum CreateReportSubject<'a> {

     

       57
       57
        
           #[serde(rename = "com.atproto.admin.defs#repoRef")]

     

       58
       58
       -
           DefsRepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       58
       58
       +
           RepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       59
       59
        
           #[serde(rename = "com.atproto.repo.strongRef")]

     

       60
       60
        
           StrongRef(Box<crate::com_atproto::repo::strong_ref::StrongRef<'a>>),

     

       61
       61
        
       }

     
···

       82
       82
        
           #[serde(borrow)]

     

       83
       83
        
           pub reported_by: jacquard_common::types::string::Did<'a>,

     

       84
       84
        
           #[serde(borrow)]

     

       85
       85
       -
           pub subject: CreateReportOutputRecordSubject<'a>,

     

       85
       85
       +
           pub subject: CreateReportOutputSubject<'a>,

     

       86
       86
        
       }

     

       87
       87
        
       

     

       88
       88
        
       #[jacquard_derive::open_union]

     
···

       97
       97
        
       )]

     

       98
       98
        
       #[serde(tag = "$type")]

     

       99
       99
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       100
       100
       -
       pub enum CreateReportOutputRecordSubject<'a> {

     

       100
       100
       +
       pub enum CreateReportOutputSubject<'a> {

     

       101
       101
        
           #[serde(rename = "com.atproto.admin.defs#repoRef")]

     

       102
       102
       -
           DefsRepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       102
       102
       +
           RepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       103
       103
        
           #[serde(rename = "com.atproto.repo.strongRef")]

     

       104
       104
        
           StrongRef(Box<crate::com_atproto::repo::strong_ref::StrongRef<'a>>),

     

       105
       105
        
       }

+44 -15

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

···

       111
       111
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       112
       112
        
           pub validate: std::option::Option<bool>,

     

       113
       113
        
           #[serde(borrow)]

     

       114
       114
       -
           pub writes: Vec<jacquard_common::types::value::Data<'a>>,

     

       114
       114
       +
           pub writes: Vec<ApplyWritesWritesItem<'a>>,

     

       115
       115
        
           #[serde(flatten)]

     

       116
       116
        
           #[serde(borrow)]

     

       117
       117
        
           #[builder(default)]

     
···

       121
       121
        
           >,

     

       122
       122
        
       }

     

       123
       123
        
       

     

       124
       124
       +
       #[derive(

     

       125
       125
       +
           serde::Serialize,

     

       126
       126
       +
           serde::Deserialize,

     

       127
       127
       +
           Debug,

     

       128
       128
       +
           Clone,

     

       129
       129
       +
           PartialEq,

     

       130
       130
       +
           Eq,

     

       131
       131
       +
           jacquard_derive::IntoStatic

     

       132
       132
       +
       )]

     

       133
       133
       +
       #[serde(tag = "$type")]

     

       134
       134
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       135
       135
       +
       pub enum ApplyWritesWritesItem<'a> {

     

       136
       136
       +
           #[serde(rename = "com.atproto.repo.applyWrites#create")]

     

       137
       137
       +
           Create(Box<crate::com_atproto::repo::apply_writes::Create<'a>>),

     

       138
       138
       +
           #[serde(rename = "com.atproto.repo.applyWrites#update")]

     

       139
       139
       +
           Update(Box<crate::com_atproto::repo::apply_writes::Update<'a>>),

     

       140
       140
       +
           #[serde(rename = "com.atproto.repo.applyWrites#delete")]

     

       141
       141
       +
           Delete(Box<crate::com_atproto::repo::apply_writes::Delete<'a>>),

     

       142
       142
       +
       }

     

       143
       143
       +
       

     

       124
       144
        
       #[jacquard_derive::lexicon]

     

       125
       145
        
       #[derive(

     

       126
       146
        
           serde::Serialize,

     
···

       138
       158
        
           pub commit: std::option::Option<crate::com_atproto::repo::CommitMeta<'a>>,

     

       139
       159
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       140
       160
        
           #[serde(borrow)]

     

       141
       141
       -
           pub results: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       161
       161
       +
           pub results: std::option::Option<Vec<ApplyWritesOutputResultsItem<'a>>>,

     

       162
       162
       +
       }

     

       163
       163
       +
       

     

       164
       164
       +
       #[derive(

     

       165
       165
       +
           serde::Serialize,

     

       166
       166
       +
           serde::Deserialize,

     

       167
       167
       +
           Debug,

     

       168
       168
       +
           Clone,

     

       169
       169
       +
           PartialEq,

     

       170
       170
       +
           Eq,

     

       171
       171
       +
           jacquard_derive::IntoStatic

     

       172
       172
       +
       )]

     

       173
       173
       +
       #[serde(tag = "$type")]

     

       174
       174
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       175
       175
       +
       pub enum ApplyWritesOutputResultsItem<'a> {

     

       176
       176
       +
           #[serde(rename = "com.atproto.repo.applyWrites#createResult")]

     

       177
       177
       +
           CreateResult(Box<crate::com_atproto::repo::apply_writes::CreateResult<'a>>),

     

       178
       178
       +
           #[serde(rename = "com.atproto.repo.applyWrites#updateResult")]

     

       179
       179
       +
           UpdateResult(Box<crate::com_atproto::repo::apply_writes::UpdateResult<'a>>),

     

       180
       180
       +
           #[serde(rename = "com.atproto.repo.applyWrites#deleteResult")]

     

       181
       181
       +
           DeleteResult(Box<crate::com_atproto::repo::apply_writes::DeleteResult<'a>>),

     

       142
       182
        
       }

     

       143
       183
        
       

     

       144
       184
        
       #[jacquard_derive::open_union]

     
···

       150
       190
        
           PartialEq,

     

       151
       191
        
           Eq,

     

       152
       192
        
           thiserror::Error,

     

       153
       153
       -
           miette::Diagnostic

     

       193
       193
       +
           miette::Diagnostic,

     

       194
       194
       +
           jacquard_derive::IntoStatic

     

       154
       195
        
       )]

     

       155
       196
        
       #[serde(tag = "error", content = "message")]

     

       156
       197
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       171
       212
        
                       Ok(())

     

       172
       213
        
                   }

     

       173
       214
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       174
       174
       -
               }

     

       175
       175
       -
           }

     

       176
       176
       -
       }

     

       177
       177
       -
       

     

       178
       178
       -
       impl jacquard_common::IntoStatic for ApplyWritesError<'_> {

     

       179
       179
       -
           type Output = ApplyWritesError<'static>;

     

       180
       180
       -
           fn into_static(self) -> Self::Output {

     

       181
       181
       -
               match self {

     

       182
       182
       -
                   ApplyWritesError::InvalidSwap(v) => {

     

       183
       183
       -
                       ApplyWritesError::InvalidSwap(v.into_static())

     

       184
       184
       -
                   }

     

       185
       185
       -
                   ApplyWritesError::Unknown(v) => ApplyWritesError::Unknown(v.into_static()),

     

       186
       215
        
               }

     

       187
       216
        
           }

     

       188
       217
        
       }

+2 -13

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

···

       85
       85
        
           PartialEq,

     

       86
       86
        
           Eq,

     

       87
       87
        
           thiserror::Error,

     

       88
       88
       -
           miette::Diagnostic

     

       88
       88
       +
           miette::Diagnostic,

     

       89
       89
       +
           jacquard_derive::IntoStatic

     

       89
       90
        
       )]

     

       90
       91
        
       #[serde(tag = "error", content = "message")]

     

       91
       92
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       106
       107
        
                       Ok(())

     

       107
       108
        
                   }

     

       108
       109
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       109
       109
       -
               }

     

       110
       110
       -
           }

     

       111
       111
       -
       }

     

       112
       112
       -
       

     

       113
       113
       -
       impl jacquard_common::IntoStatic for CreateRecordError<'_> {

     

       114
       114
       -
           type Output = CreateRecordError<'static>;

     

       115
       115
       -
           fn into_static(self) -> Self::Output {

     

       116
       116
       -
               match self {

     

       117
       117
       -
                   CreateRecordError::InvalidSwap(v) => {

     

       118
       118
       -
                       CreateRecordError::InvalidSwap(v.into_static())

     

       119
       119
       -
                   }

     

       120
       120
       -
                   CreateRecordError::Unknown(v) => CreateRecordError::Unknown(v.into_static()),

     

       121
       110
        
               }

     

       122
       111
        
           }

     

       123
       112
        
       }

+2 -13

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

···

       73
       73
        
           PartialEq,

     

       74
       74
        
           Eq,

     

       75
       75
        
           thiserror::Error,

     

       76
       76
       -
           miette::Diagnostic

     

       76
       76
       +
           miette::Diagnostic,

     

       77
       77
       +
           jacquard_derive::IntoStatic

     

       77
       78
        
       )]

     

       78
       79
        
       #[serde(tag = "error", content = "message")]

     

       79
       80
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       93
       94
        
                       Ok(())

     

       94
       95
        
                   }

     

       95
       96
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       96
       96
       -
               }

     

       97
       97
       -
           }

     

       98
       98
       -
       }

     

       99
       99
       -
       

     

       100
       100
       -
       impl jacquard_common::IntoStatic for DeleteRecordError<'_> {

     

       101
       101
       -
           type Output = DeleteRecordError<'static>;

     

       102
       102
       -
           fn into_static(self) -> Self::Output {

     

       103
       103
       -
               match self {

     

       104
       104
       -
                   DeleteRecordError::InvalidSwap(v) => {

     

       105
       105
       -
                       DeleteRecordError::InvalidSwap(v.into_static())

     

       106
       106
       -
                   }

     

       107
       107
       -
                   DeleteRecordError::Unknown(v) => DeleteRecordError::Unknown(v.into_static()),

     

       108
       97
        
               }

     

       109
       98
        
           }

     

       110
       99
        
       }

+2 -13

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

···

       61
       61
        
           PartialEq,

     

       62
       62
        
           Eq,

     

       63
       63
        
           thiserror::Error,

     

       64
       64
       -
           miette::Diagnostic

     

       64
       64
       +
           miette::Diagnostic,

     

       65
       65
       +
           jacquard_derive::IntoStatic

     

       65
       66
        
       )]

     

       66
       67
        
       #[serde(tag = "error", content = "message")]

     

       67
       68
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       81
       82
        
                       Ok(())

     

       82
       83
        
                   }

     

       83
       84
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       84
       84
       -
               }

     

       85
       85
       -
           }

     

       86
       86
       -
       }

     

       87
       87
       -
       

     

       88
       88
       -
       impl jacquard_common::IntoStatic for GetRecordError<'_> {

     

       89
       89
       -
           type Output = GetRecordError<'static>;

     

       90
       90
       -
           fn into_static(self) -> Self::Output {

     

       91
       91
       -
               match self {

     

       92
       92
       -
                   GetRecordError::RecordNotFound(v) => {

     

       93
       93
       -
                       GetRecordError::RecordNotFound(v.into_static())

     

       94
       94
       -
                   }

     

       95
       95
       -
                   GetRecordError::Unknown(v) => GetRecordError::Unknown(v.into_static()),

     

       96
       85
        
               }

     

       97
       86
        
           }

     

       98
       87
        
       }

+2 -13

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

···

       86
       86
        
           PartialEq,

     

       87
       87
        
           Eq,

     

       88
       88
        
           thiserror::Error,

     

       89
       89
       -
           miette::Diagnostic

     

       89
       89
       +
           miette::Diagnostic,

     

       90
       90
       +
           jacquard_derive::IntoStatic

     

       90
       91
        
       )]

     

       91
       92
        
       #[serde(tag = "error", content = "message")]

     

       92
       93
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       106
       107
        
                       Ok(())

     

       107
       108
        
                   }

     

       108
       109
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       109
       109
       -
               }

     

       110
       110
       -
           }

     

       111
       111
       -
       }

     

       112
       112
       -
       

     

       113
       113
       -
       impl jacquard_common::IntoStatic for PutRecordError<'_> {

     

       114
       114
       -
           type Output = PutRecordError<'static>;

     

       115
       115
       -
           fn into_static(self) -> Self::Output {

     

       116
       116
       -
               match self {

     

       117
       117
       -
                   PutRecordError::InvalidSwap(v) => {

     

       118
       118
       -
                       PutRecordError::InvalidSwap(v.into_static())

     

       119
       119
       -
                   }

     

       120
       120
       -
                   PutRecordError::Unknown(v) => PutRecordError::Unknown(v.into_static()),

     

       121
       110
        
               }

     

       122
       111
        
           }

     

       123
       112
        
       }

+2 -22

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

···

       43
       43
        
           PartialEq,

     

       44
       44
        
           Eq,

     

       45
       45
        
           thiserror::Error,

     

       46
       46
       -
           miette::Diagnostic

     

       46
       46
       +
           miette::Diagnostic,

     

       47
       47
       +
           jacquard_derive::IntoStatic

     

       47
       48
        
       )]

     

       48
       49
        
       #[serde(tag = "error", content = "message")]

     

       49
       50
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       90
       91
        
                       Ok(())

     

       91
       92
        
                   }

     

       92
       93
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       93
       93
       -
               }

     

       94
       94
       -
           }

     

       95
       95
       -
       }

     

       96
       96
       -
       

     

       97
       97
       -
       impl jacquard_common::IntoStatic for ConfirmEmailError<'_> {

     

       98
       98
       -
           type Output = ConfirmEmailError<'static>;

     

       99
       99
       -
           fn into_static(self) -> Self::Output {

     

       100
       100
       -
               match self {

     

       101
       101
       -
                   ConfirmEmailError::AccountNotFound(v) => {

     

       102
       102
       -
                       ConfirmEmailError::AccountNotFound(v.into_static())

     

       103
       103
       -
                   }

     

       104
       104
       -
                   ConfirmEmailError::ExpiredToken(v) => {

     

       105
       105
       -
                       ConfirmEmailError::ExpiredToken(v.into_static())

     

       106
       106
       -
                   }

     

       107
       107
       -
                   ConfirmEmailError::InvalidToken(v) => {

     

       108
       108
       -
                       ConfirmEmailError::InvalidToken(v.into_static())

     

       109
       109
       -
                   }

     

       110
       110
       -
                   ConfirmEmailError::InvalidEmail(v) => {

     

       111
       111
       -
                       ConfirmEmailError::InvalidEmail(v.into_static())

     

       112
       112
       -
                   }

     

       113
       113
       -
                   ConfirmEmailError::Unknown(v) => ConfirmEmailError::Unknown(v.into_static()),

     

       114
       94
        
               }

     

       115
       95
        
           }

     

       116
       96
        
       }

+2 -33

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

···

       101
       101
        
           PartialEq,

     

       102
       102
        
           Eq,

     

       103
       103
        
           thiserror::Error,

     

       104
       104
       -
           miette::Diagnostic

     

       104
       104
       +
           miette::Diagnostic,

     

       105
       105
       +
           jacquard_derive::IntoStatic

     

       105
       106
        
       )]

     

       106
       107
        
       #[serde(tag = "error", content = "message")]

     

       107
       108
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       175
       176
        
                       Ok(())

     

       176
       177
        
                   }

     

       177
       178
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       178
       178
       -
               }

     

       179
       179
       -
           }

     

       180
       180
       -
       }

     

       181
       181
       -
       

     

       182
       182
       -
       impl jacquard_common::IntoStatic for CreateAccountError<'_> {

     

       183
       183
       -
           type Output = CreateAccountError<'static>;

     

       184
       184
       -
           fn into_static(self) -> Self::Output {

     

       185
       185
       -
               match self {

     

       186
       186
       -
                   CreateAccountError::InvalidHandle(v) => {

     

       187
       187
       -
                       CreateAccountError::InvalidHandle(v.into_static())

     

       188
       188
       -
                   }

     

       189
       189
       -
                   CreateAccountError::InvalidPassword(v) => {

     

       190
       190
       -
                       CreateAccountError::InvalidPassword(v.into_static())

     

       191
       191
       -
                   }

     

       192
       192
       -
                   CreateAccountError::InvalidInviteCode(v) => {

     

       193
       193
       -
                       CreateAccountError::InvalidInviteCode(v.into_static())

     

       194
       194
       -
                   }

     

       195
       195
       -
                   CreateAccountError::HandleNotAvailable(v) => {

     

       196
       196
       -
                       CreateAccountError::HandleNotAvailable(v.into_static())

     

       197
       197
       -
                   }

     

       198
       198
       -
                   CreateAccountError::UnsupportedDomain(v) => {

     

       199
       199
       -
                       CreateAccountError::UnsupportedDomain(v.into_static())

     

       200
       200
       -
                   }

     

       201
       201
       -
                   CreateAccountError::UnresolvableDid(v) => {

     

       202
       202
       -
                       CreateAccountError::UnresolvableDid(v.into_static())

     

       203
       203
       -
                   }

     

       204
       204
       -
                   CreateAccountError::IncompatibleDidDoc(v) => {

     

       205
       205
       -
                       CreateAccountError::IncompatibleDidDoc(v.into_static())

     

       206
       206
       -
                   }

     

       207
       207
       -
                   CreateAccountError::Unknown(v) => {

     

       208
       208
       -
                       CreateAccountError::Unknown(v.into_static())

     

       209
       209
       -
                   }

     

       210
       179
        
               }

     

       211
       180
        
           }

     

       212
       181
        
       }

+2 -15

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

···

       82
       82
        
           PartialEq,

     

       83
       83
        
           Eq,

     

       84
       84
        
           thiserror::Error,

     

       85
       85
       -
           miette::Diagnostic

     

       85
       85
       +
           miette::Diagnostic,

     

       86
       86
       +
           jacquard_derive::IntoStatic

     

       86
       87
        
       )]

     

       87
       88
        
       #[serde(tag = "error", content = "message")]

     

       88
       89
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       102
       103
        
                       Ok(())

     

       103
       104
        
                   }

     

       104
       105
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       105
       105
       -
               }

     

       106
       106
       -
           }

     

       107
       107
       -
       }

     

       108
       108
       -
       

     

       109
       109
       -
       impl jacquard_common::IntoStatic for CreateAppPasswordError<'_> {

     

       110
       110
       -
           type Output = CreateAppPasswordError<'static>;

     

       111
       111
       -
           fn into_static(self) -> Self::Output {

     

       112
       112
       -
               match self {

     

       113
       113
       -
                   CreateAppPasswordError::AccountTakedown(v) => {

     

       114
       114
       -
                       CreateAppPasswordError::AccountTakedown(v.into_static())

     

       115
       115
       -
                   }

     

       116
       116
       -
                   CreateAppPasswordError::Unknown(v) => {

     

       117
       117
       -
                       CreateAppPasswordError::Unknown(v.into_static())

     

       118
       118
       -
                   }

     

       119
       106
        
               }

     

       120
       107
        
           }

     

       121
       108
        
       }

+2 -18

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

···

       89
       89
        
           PartialEq,

     

       90
       90
        
           Eq,

     

       91
       91
        
           thiserror::Error,

     

       92
       92
       -
           miette::Diagnostic

     

       92
       92
       +
           miette::Diagnostic,

     

       93
       93
       +
           jacquard_derive::IntoStatic

     

       93
       94
        
       )]

     

       94
       95
        
       #[serde(tag = "error", content = "message")]

     

       95
       96
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       118
       119
        
                       Ok(())

     

       119
       120
        
                   }

     

       120
       121
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       121
       121
       -
               }

     

       122
       122
       -
           }

     

       123
       123
       -
       }

     

       124
       124
       -
       

     

       125
       125
       -
       impl jacquard_common::IntoStatic for CreateSessionError<'_> {

     

       126
       126
       -
           type Output = CreateSessionError<'static>;

     

       127
       127
       -
           fn into_static(self) -> Self::Output {

     

       128
       128
       -
               match self {

     

       129
       129
       -
                   CreateSessionError::AccountTakedown(v) => {

     

       130
       130
       -
                       CreateSessionError::AccountTakedown(v.into_static())

     

       131
       131
       -
                   }

     

       132
       132
       -
                   CreateSessionError::AuthFactorTokenRequired(v) => {

     

       133
       133
       -
                       CreateSessionError::AuthFactorTokenRequired(v.into_static())

     

       134
       134
       -
                   }

     

       135
       135
       -
                   CreateSessionError::Unknown(v) => {

     

       136
       136
       -
                       CreateSessionError::Unknown(v.into_static())

     

       137
       137
       -
                   }

     

       138
       122
        
               }

     

       139
       123
        
           }

     

       140
       124
        
       }

+2 -18

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

···

       45
       45
        
           PartialEq,

     

       46
       46
        
           Eq,

     

       47
       47
        
           thiserror::Error,

     

       48
       48
       -
           miette::Diagnostic

     

       48
       48
       +
           miette::Diagnostic,

     

       49
       49
       +
           jacquard_derive::IntoStatic

     

       49
       50
        
       )]

     

       50
       51
        
       #[serde(tag = "error", content = "message")]

     

       51
       52
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       74
       75
        
                       Ok(())

     

       75
       76
        
                   }

     

       76
       77
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       77
       77
       -
               }

     

       78
       78
       -
           }

     

       79
       79
       -
       }

     

       80
       80
       -
       

     

       81
       81
       -
       impl jacquard_common::IntoStatic for DeleteAccountError<'_> {

     

       82
       82
       -
           type Output = DeleteAccountError<'static>;

     

       83
       83
       -
           fn into_static(self) -> Self::Output {

     

       84
       84
       -
               match self {

     

       85
       85
       -
                   DeleteAccountError::ExpiredToken(v) => {

     

       86
       86
       -
                       DeleteAccountError::ExpiredToken(v.into_static())

     

       87
       87
       -
                   }

     

       88
       88
       -
                   DeleteAccountError::InvalidToken(v) => {

     

       89
       89
       -
                       DeleteAccountError::InvalidToken(v.into_static())

     

       90
       90
       -
                   }

     

       91
       91
       -
                   DeleteAccountError::Unknown(v) => {

     

       92
       92
       -
                       DeleteAccountError::Unknown(v.into_static())

     

       93
       93
       -
                   }

     

       94
       78
        
               }

     

       95
       79
        
           }

     

       96
       80
        
       }

+2 -15

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

···

       51
       51
        
           PartialEq,

     

       52
       52
        
           Eq,

     

       53
       53
        
           thiserror::Error,

     

       54
       54
       -
           miette::Diagnostic

     

       54
       54
       +
           miette::Diagnostic,

     

       55
       55
       +
           jacquard_derive::IntoStatic

     

       55
       56
        
       )]

     

       56
       57
        
       #[serde(tag = "error", content = "message")]

     

       57
       58
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       71
       72
        
                       Ok(())

     

       72
       73
        
                   }

     

       73
       74
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       74
       74
       -
               }

     

       75
       75
       -
           }

     

       76
       76
       -
       }

     

       77
       77
       -
       

     

       78
       78
       -
       impl jacquard_common::IntoStatic for GetAccountInviteCodesError<'_> {

     

       79
       79
       -
           type Output = GetAccountInviteCodesError<'static>;

     

       80
       80
       -
           fn into_static(self) -> Self::Output {

     

       81
       81
       -
               match self {

     

       82
       82
       -
                   GetAccountInviteCodesError::DuplicateCreate(v) => {

     

       83
       83
       -
                       GetAccountInviteCodesError::DuplicateCreate(v.into_static())

     

       84
       84
       -
                   }

     

       85
       85
       -
                   GetAccountInviteCodesError::Unknown(v) => {

     

       86
       86
       -
                       GetAccountInviteCodesError::Unknown(v.into_static())

     

       87
       87
       -
                   }

     

       88
       75
        
               }

     

       89
       76
        
           }

     

       90
       77
        
       }

+2 -15

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

···

       52
       52
        
           PartialEq,

     

       53
       53
        
           Eq,

     

       54
       54
        
           thiserror::Error,

     

       55
       55
       -
           miette::Diagnostic

     

       55
       55
       +
           miette::Diagnostic,

     

       56
       56
       +
           jacquard_derive::IntoStatic

     

       56
       57
        
       )]

     

       57
       58
        
       #[serde(tag = "error", content = "message")]

     

       58
       59
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       73
       74
        
                       Ok(())

     

       74
       75
        
                   }

     

       75
       76
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       76
       76
       -
               }

     

       77
       77
       -
           }

     

       78
       78
       -
       }

     

       79
       79
       -
       

     

       80
       80
       -
       impl jacquard_common::IntoStatic for GetServiceAuthError<'_> {

     

       81
       81
       -
           type Output = GetServiceAuthError<'static>;

     

       82
       82
       -
           fn into_static(self) -> Self::Output {

     

       83
       83
       -
               match self {

     

       84
       84
       -
                   GetServiceAuthError::BadExpiration(v) => {

     

       85
       85
       -
                       GetServiceAuthError::BadExpiration(v.into_static())

     

       86
       86
       -
                   }

     

       87
       87
       -
                   GetServiceAuthError::Unknown(v) => {

     

       88
       88
       -
                       GetServiceAuthError::Unknown(v.into_static())

     

       89
       89
       -
                   }

     

       90
       77
        
               }

     

       91
       78
        
           }

     

       92
       79
        
       }

+2 -15

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

···

       49
       49
        
           PartialEq,

     

       50
       50
        
           Eq,

     

       51
       51
        
           thiserror::Error,

     

       52
       52
       -
           miette::Diagnostic

     

       52
       52
       +
           miette::Diagnostic,

     

       53
       53
       +
           jacquard_derive::IntoStatic

     

       53
       54
        
       )]

     

       54
       55
        
       #[serde(tag = "error", content = "message")]

     

       55
       56
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       69
       70
        
                       Ok(())

     

       70
       71
        
                   }

     

       71
       72
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       72
       72
       -
               }

     

       73
       73
       -
           }

     

       74
       74
       -
       }

     

       75
       75
       -
       

     

       76
       76
       -
       impl jacquard_common::IntoStatic for ListAppPasswordsError<'_> {

     

       77
       77
       -
           type Output = ListAppPasswordsError<'static>;

     

       78
       78
       -
           fn into_static(self) -> Self::Output {

     

       79
       79
       -
               match self {

     

       80
       80
       -
                   ListAppPasswordsError::AccountTakedown(v) => {

     

       81
       81
       -
                       ListAppPasswordsError::AccountTakedown(v.into_static())

     

       82
       82
       -
                   }

     

       83
       83
       -
                   ListAppPasswordsError::Unknown(v) => {

     

       84
       84
       -
                       ListAppPasswordsError::Unknown(v.into_static())

     

       85
       85
       -
                   }

     

       86
       73
        
               }

     

       87
       74
        
           }

     

       88
       75
        
       }

+2 -15

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

···

       45
       45
        
           PartialEq,

     

       46
       46
        
           Eq,

     

       47
       47
        
           thiserror::Error,

     

       48
       48
       -
           miette::Diagnostic

     

       48
       48
       +
           miette::Diagnostic,

     

       49
       49
       +
           jacquard_derive::IntoStatic

     

       49
       50
        
       )]

     

       50
       51
        
       #[serde(tag = "error", content = "message")]

     

       51
       52
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       65
       66
        
                       Ok(())

     

       66
       67
        
                   }

     

       67
       68
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       68
       68
       -
               }

     

       69
       69
       -
           }

     

       70
       70
       -
       }

     

       71
       71
       -
       

     

       72
       72
       -
       impl jacquard_common::IntoStatic for RefreshSessionError<'_> {

     

       73
       73
       -
           type Output = RefreshSessionError<'static>;

     

       74
       74
       -
           fn into_static(self) -> Self::Output {

     

       75
       75
       -
               match self {

     

       76
       76
       -
                   RefreshSessionError::AccountTakedown(v) => {

     

       77
       77
       -
                       RefreshSessionError::AccountTakedown(v.into_static())

     

       78
       78
       -
                   }

     

       79
       79
       -
                   RefreshSessionError::Unknown(v) => {

     

       80
       80
       -
                       RefreshSessionError::Unknown(v.into_static())

     

       81
       81
       -
                   }

     

       82
       69
        
               }

     

       83
       70
        
           }

     

       84
       71
        
       }

+2 -18

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

···

       43
       43
        
           PartialEq,

     

       44
       44
        
           Eq,

     

       45
       45
        
           thiserror::Error,

     

       46
       46
       -
           miette::Diagnostic

     

       46
       46
       +
           miette::Diagnostic,

     

       47
       47
       +
           jacquard_derive::IntoStatic

     

       47
       48
        
       )]

     

       48
       49
        
       #[serde(tag = "error", content = "message")]

     

       49
       50
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       72
       73
        
                       Ok(())

     

       73
       74
        
                   }

     

       74
       75
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       75
       75
       -
               }

     

       76
       76
       -
           }

     

       77
       77
       -
       }

     

       78
       78
       -
       

     

       79
       79
       -
       impl jacquard_common::IntoStatic for ResetPasswordError<'_> {

     

       80
       80
       -
           type Output = ResetPasswordError<'static>;

     

       81
       81
       -
           fn into_static(self) -> Self::Output {

     

       82
       82
       -
               match self {

     

       83
       83
       -
                   ResetPasswordError::ExpiredToken(v) => {

     

       84
       84
       -
                       ResetPasswordError::ExpiredToken(v.into_static())

     

       85
       85
       -
                   }

     

       86
       86
       -
                   ResetPasswordError::InvalidToken(v) => {

     

       87
       87
       -
                       ResetPasswordError::InvalidToken(v.into_static())

     

       88
       88
       -
                   }

     

       89
       89
       -
                   ResetPasswordError::Unknown(v) => {

     

       90
       90
       -
                       ResetPasswordError::Unknown(v.into_static())

     

       91
       91
       -
                   }

     

       92
       76
        
               }

     

       93
       77
        
           }

     

       94
       78
        
       }

+2 -19

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

···

       47
       47
        
           PartialEq,

     

       48
       48
        
           Eq,

     

       49
       49
        
           thiserror::Error,

     

       50
       50
       -
           miette::Diagnostic

     

       50
       50
       +
           miette::Diagnostic,

     

       51
       51
       +
           jacquard_derive::IntoStatic

     

       51
       52
        
       )]

     

       52
       53
        
       #[serde(tag = "error", content = "message")]

     

       53
       54
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       85
       86
        
                       Ok(())

     

       86
       87
        
                   }

     

       87
       88
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       88
       88
       -
               }

     

       89
       89
       -
           }

     

       90
       90
       -
       }

     

       91
       91
       -
       

     

       92
       92
       -
       impl jacquard_common::IntoStatic for UpdateEmailError<'_> {

     

       93
       93
       -
           type Output = UpdateEmailError<'static>;

     

       94
       94
       -
           fn into_static(self) -> Self::Output {

     

       95
       95
       -
               match self {

     

       96
       96
       -
                   UpdateEmailError::ExpiredToken(v) => {

     

       97
       97
       -
                       UpdateEmailError::ExpiredToken(v.into_static())

     

       98
       98
       -
                   }

     

       99
       99
       -
                   UpdateEmailError::InvalidToken(v) => {

     

       100
       100
       -
                       UpdateEmailError::InvalidToken(v.into_static())

     

       101
       101
       -
                   }

     

       102
       102
       -
                   UpdateEmailError::TokenRequired(v) => {

     

       103
       103
       -
                       UpdateEmailError::TokenRequired(v.into_static())

     

       104
       104
       -
                   }

     

       105
       105
       -
                   UpdateEmailError::Unknown(v) => UpdateEmailError::Unknown(v.into_static()),

     

       106
       89
        
               }

     

       107
       90
        
           }

     

       108
       91
        
       }

+2 -21

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

···

       45
       45
        
           PartialEq,

     

       46
       46
        
           Eq,

     

       47
       47
        
           thiserror::Error,

     

       48
       48
       -
           miette::Diagnostic

     

       48
       48
       +
           miette::Diagnostic,

     

       49
       49
       +
           jacquard_derive::IntoStatic

     

       49
       50
        
       )]

     

       50
       51
        
       #[serde(tag = "error", content = "message")]

     

       51
       52
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       101
       102
        
                       Ok(())

     

       102
       103
        
                   }

     

       103
       104
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       104
       104
       -
               }

     

       105
       105
       -
           }

     

       106
       106
       -
       }

     

       107
       107
       -
       

     

       108
       108
       -
       impl jacquard_common::IntoStatic for GetBlobError<'_> {

     

       109
       109
       -
           type Output = GetBlobError<'static>;

     

       110
       110
       -
           fn into_static(self) -> Self::Output {

     

       111
       111
       -
               match self {

     

       112
       112
       -
                   GetBlobError::BlobNotFound(v) => GetBlobError::BlobNotFound(v.into_static()),

     

       113
       113
       -
                   GetBlobError::RepoNotFound(v) => GetBlobError::RepoNotFound(v.into_static()),

     

       114
       114
       -
                   GetBlobError::RepoTakendown(v) => {

     

       115
       115
       -
                       GetBlobError::RepoTakendown(v.into_static())

     

       116
       116
       -
                   }

     

       117
       117
       -
                   GetBlobError::RepoSuspended(v) => {

     

       118
       118
       -
                       GetBlobError::RepoSuspended(v.into_static())

     

       119
       119
       -
                   }

     

       120
       120
       -
                   GetBlobError::RepoDeactivated(v) => {

     

       121
       121
       -
                       GetBlobError::RepoDeactivated(v.into_static())

     

       122
       122
       -
                   }

     

       123
       123
       -
                   GetBlobError::Unknown(v) => GetBlobError::Unknown(v.into_static()),

     

       124
       105
        
               }

     

       125
       106
        
           }

     

       126
       107
        
       }

+2 -25

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

···

       45
       45
        
           PartialEq,

     

       46
       46
        
           Eq,

     

       47
       47
        
           thiserror::Error,

     

       48
       48
       -
           miette::Diagnostic

     

       48
       48
       +
           miette::Diagnostic,

     

       49
       49
       +
           jacquard_derive::IntoStatic

     

       49
       50
        
       )]

     

       50
       51
        
       #[serde(tag = "error", content = "message")]

     

       51
       52
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       101
       102
        
                       Ok(())

     

       102
       103
        
                   }

     

       103
       104
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       104
       104
       -
               }

     

       105
       105
       -
           }

     

       106
       106
       -
       }

     

       107
       107
       -
       

     

       108
       108
       -
       impl jacquard_common::IntoStatic for GetBlocksError<'_> {

     

       109
       109
       -
           type Output = GetBlocksError<'static>;

     

       110
       110
       -
           fn into_static(self) -> Self::Output {

     

       111
       111
       -
               match self {

     

       112
       112
       -
                   GetBlocksError::BlockNotFound(v) => {

     

       113
       113
       -
                       GetBlocksError::BlockNotFound(v.into_static())

     

       114
       114
       -
                   }

     

       115
       115
       -
                   GetBlocksError::RepoNotFound(v) => {

     

       116
       116
       -
                       GetBlocksError::RepoNotFound(v.into_static())

     

       117
       117
       -
                   }

     

       118
       118
       -
                   GetBlocksError::RepoTakendown(v) => {

     

       119
       119
       -
                       GetBlocksError::RepoTakendown(v.into_static())

     

       120
       120
       -
                   }

     

       121
       121
       -
                   GetBlocksError::RepoSuspended(v) => {

     

       122
       122
       -
                       GetBlocksError::RepoSuspended(v.into_static())

     

       123
       123
       -
                   }

     

       124
       124
       -
                   GetBlocksError::RepoDeactivated(v) => {

     

       125
       125
       -
                       GetBlocksError::RepoDeactivated(v.into_static())

     

       126
       126
       -
                   }

     

       127
       127
       -
                   GetBlocksError::Unknown(v) => GetBlocksError::Unknown(v.into_static()),

     

       128
       105
        
               }

     

       129
       106
        
           }

     

       130
       107
        
       }

+2 -11

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

···

       47
       47
        
           PartialEq,

     

       48
       48
        
           Eq,

     

       49
       49
        
           thiserror::Error,

     

       50
       50
       -
           miette::Diagnostic

     

       50
       50
       +
           miette::Diagnostic,

     

       51
       51
       +
           jacquard_derive::IntoStatic

     

       51
       52
        
       )]

     

       52
       53
        
       #[serde(tag = "error", content = "message")]

     

       53
       54
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       67
       68
        
                       Ok(())

     

       68
       69
        
                   }

     

       69
       70
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       70
       70
       -
               }

     

       71
       71
       -
           }

     

       72
       72
       -
       }

     

       73
       73
       -
       

     

       74
       74
       -
       impl jacquard_common::IntoStatic for GetHeadError<'_> {

     

       75
       75
       -
           type Output = GetHeadError<'static>;

     

       76
       76
       -
           fn into_static(self) -> Self::Output {

     

       77
       77
       -
               match self {

     

       78
       78
       -
                   GetHeadError::HeadNotFound(v) => GetHeadError::HeadNotFound(v.into_static()),

     

       79
       79
       -
                   GetHeadError::Unknown(v) => GetHeadError::Unknown(v.into_static()),

     

       80
       71
        
               }

     

       81
       72
        
           }

     

       82
       73
        
       }

+2 -15

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

···

       57
       57
        
           PartialEq,

     

       58
       58
        
           Eq,

     

       59
       59
        
           thiserror::Error,

     

       60
       60
       -
           miette::Diagnostic

     

       60
       60
       +
           miette::Diagnostic,

     

       61
       61
       +
           jacquard_derive::IntoStatic

     

       61
       62
        
       )]

     

       62
       63
        
       #[serde(tag = "error", content = "message")]

     

       63
       64
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       77
       78
        
                       Ok(())

     

       78
       79
        
                   }

     

       79
       80
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       80
       80
       -
               }

     

       81
       81
       -
           }

     

       82
       82
       -
       }

     

       83
       83
       -
       

     

       84
       84
       -
       impl jacquard_common::IntoStatic for GetHostStatusError<'_> {

     

       85
       85
       -
           type Output = GetHostStatusError<'static>;

     

       86
       86
       -
           fn into_static(self) -> Self::Output {

     

       87
       87
       -
               match self {

     

       88
       88
       -
                   GetHostStatusError::HostNotFound(v) => {

     

       89
       89
       -
                       GetHostStatusError::HostNotFound(v.into_static())

     

       90
       90
       -
                   }

     

       91
       91
       -
                   GetHostStatusError::Unknown(v) => {

     

       92
       92
       -
                       GetHostStatusError::Unknown(v.into_static())

     

       93
       93
       -
                   }

     

       94
       81
        
               }

     

       95
       82
        
           }

     

       96
       83
        
       }

+2 -24

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

···

       48
       48
        
           PartialEq,

     

       49
       49
        
           Eq,

     

       50
       50
        
           thiserror::Error,

     

       51
       51
       -
           miette::Diagnostic

     

       51
       51
       +
           miette::Diagnostic,

     

       52
       52
       +
           jacquard_derive::IntoStatic

     

       52
       53
        
       )]

     

       53
       54
        
       #[serde(tag = "error", content = "message")]

     

       54
       55
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       95
       96
        
                       Ok(())

     

       96
       97
        
                   }

     

       97
       98
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       98
       98
       -
               }

     

       99
       99
       -
           }

     

       100
       100
       -
       }

     

       101
       101
       -
       

     

       102
       102
       -
       impl jacquard_common::IntoStatic for GetLatestCommitError<'_> {

     

       103
       103
       -
           type Output = GetLatestCommitError<'static>;

     

       104
       104
       -
           fn into_static(self) -> Self::Output {

     

       105
       105
       -
               match self {

     

       106
       106
       -
                   GetLatestCommitError::RepoNotFound(v) => {

     

       107
       107
       -
                       GetLatestCommitError::RepoNotFound(v.into_static())

     

       108
       108
       -
                   }

     

       109
       109
       -
                   GetLatestCommitError::RepoTakendown(v) => {

     

       110
       110
       -
                       GetLatestCommitError::RepoTakendown(v.into_static())

     

       111
       111
       -
                   }

     

       112
       112
       -
                   GetLatestCommitError::RepoSuspended(v) => {

     

       113
       113
       -
                       GetLatestCommitError::RepoSuspended(v.into_static())

     

       114
       114
       -
                   }

     

       115
       115
       -
                   GetLatestCommitError::RepoDeactivated(v) => {

     

       116
       116
       -
                       GetLatestCommitError::RepoDeactivated(v.into_static())

     

       117
       117
       -
                   }

     

       118
       118
       -
                   GetLatestCommitError::Unknown(v) => {

     

       119
       119
       -
                       GetLatestCommitError::Unknown(v.into_static())

     

       120
       120
       -
                   }

     

       121
       99
        
               }

     

       122
       100
        
           }

     

       123
       101
        
       }

+2 -25

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

···

       49
       49
        
           PartialEq,

     

       50
       50
        
           Eq,

     

       51
       51
        
           thiserror::Error,

     

       52
       52
       -
           miette::Diagnostic

     

       52
       52
       +
           miette::Diagnostic,

     

       53
       53
       +
           jacquard_derive::IntoStatic

     

       53
       54
        
       )]

     

       54
       55
        
       #[serde(tag = "error", content = "message")]

     

       55
       56
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       105
       106
        
                       Ok(())

     

       106
       107
        
                   }

     

       107
       108
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       108
       108
       -
               }

     

       109
       109
       -
           }

     

       110
       110
       -
       }

     

       111
       111
       -
       

     

       112
       112
       -
       impl jacquard_common::IntoStatic for GetRecordError<'_> {

     

       113
       113
       -
           type Output = GetRecordError<'static>;

     

       114
       114
       -
           fn into_static(self) -> Self::Output {

     

       115
       115
       -
               match self {

     

       116
       116
       -
                   GetRecordError::RecordNotFound(v) => {

     

       117
       117
       -
                       GetRecordError::RecordNotFound(v.into_static())

     

       118
       118
       -
                   }

     

       119
       119
       -
                   GetRecordError::RepoNotFound(v) => {

     

       120
       120
       -
                       GetRecordError::RepoNotFound(v.into_static())

     

       121
       121
       -
                   }

     

       122
       122
       -
                   GetRecordError::RepoTakendown(v) => {

     

       123
       123
       -
                       GetRecordError::RepoTakendown(v.into_static())

     

       124
       124
       -
                   }

     

       125
       125
       -
                   GetRecordError::RepoSuspended(v) => {

     

       126
       126
       -
                       GetRecordError::RepoSuspended(v.into_static())

     

       127
       127
       -
                   }

     

       128
       128
       -
                   GetRecordError::RepoDeactivated(v) => {

     

       129
       129
       -
                       GetRecordError::RepoDeactivated(v.into_static())

     

       130
       130
       -
                   }

     

       131
       131
       -
                   GetRecordError::Unknown(v) => GetRecordError::Unknown(v.into_static()),

     

       132
       109
        
               }

     

       133
       110
        
           }

     

       134
       111
        
       }

+2 -20

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

···

       45
       45
        
           PartialEq,

     

       46
       46
        
           Eq,

     

       47
       47
        
           thiserror::Error,

     

       48
       48
       -
           miette::Diagnostic

     

       48
       48
       +
           miette::Diagnostic,

     

       49
       49
       +
           jacquard_derive::IntoStatic

     

       49
       50
        
       )]

     

       50
       51
        
       #[serde(tag = "error", content = "message")]

     

       51
       52
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       92
       93
        
                       Ok(())

     

       93
       94
        
                   }

     

       94
       95
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       95
       95
       -
               }

     

       96
       96
       -
           }

     

       97
       97
       -
       }

     

       98
       98
       -
       

     

       99
       99
       -
       impl jacquard_common::IntoStatic for GetRepoError<'_> {

     

       100
       100
       -
           type Output = GetRepoError<'static>;

     

       101
       101
       -
           fn into_static(self) -> Self::Output {

     

       102
       102
       -
               match self {

     

       103
       103
       -
                   GetRepoError::RepoNotFound(v) => GetRepoError::RepoNotFound(v.into_static()),

     

       104
       104
       -
                   GetRepoError::RepoTakendown(v) => {

     

       105
       105
       -
                       GetRepoError::RepoTakendown(v.into_static())

     

       106
       106
       -
                   }

     

       107
       107
       -
                   GetRepoError::RepoSuspended(v) => {

     

       108
       108
       -
                       GetRepoError::RepoSuspended(v.into_static())

     

       109
       109
       -
                   }

     

       110
       110
       -
                   GetRepoError::RepoDeactivated(v) => {

     

       111
       111
       -
                       GetRepoError::RepoDeactivated(v.into_static())

     

       112
       112
       -
                   }

     

       113
       113
       -
                   GetRepoError::Unknown(v) => GetRepoError::Unknown(v.into_static()),

     

       114
       96
        
               }

     

       115
       97
        
           }

     

       116
       98
        
       }

+2 -15

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

···

       55
       55
        
           PartialEq,

     

       56
       56
        
           Eq,

     

       57
       57
        
           thiserror::Error,

     

       58
       58
       -
           miette::Diagnostic

     

       58
       58
       +
           miette::Diagnostic,

     

       59
       59
       +
           jacquard_derive::IntoStatic

     

       59
       60
        
       )]

     

       60
       61
        
       #[serde(tag = "error", content = "message")]

     

       61
       62
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       75
       76
        
                       Ok(())

     

       76
       77
        
                   }

     

       77
       78
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       78
       78
       -
               }

     

       79
       79
       -
           }

     

       80
       80
       -
       }

     

       81
       81
       -
       

     

       82
       82
       -
       impl jacquard_common::IntoStatic for GetRepoStatusError<'_> {

     

       83
       83
       -
           type Output = GetRepoStatusError<'static>;

     

       84
       84
       -
           fn into_static(self) -> Self::Output {

     

       85
       85
       -
               match self {

     

       86
       86
       -
                   GetRepoStatusError::RepoNotFound(v) => {

     

       87
       87
       -
                       GetRepoStatusError::RepoNotFound(v.into_static())

     

       88
       88
       -
                   }

     

       89
       89
       -
                   GetRepoStatusError::Unknown(v) => {

     

       90
       90
       -
                       GetRepoStatusError::Unknown(v.into_static())

     

       91
       91
       -
                   }

     

       92
       79
        
               }

     

       93
       80
        
           }

     

       94
       81
        
       }

+2 -22

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

···

       59
       59
        
           PartialEq,

     

       60
       60
        
           Eq,

     

       61
       61
        
           thiserror::Error,

     

       62
       62
       -
           miette::Diagnostic

     

       62
       62
       +
           miette::Diagnostic,

     

       63
       63
       +
           jacquard_derive::IntoStatic

     

       63
       64
        
       )]

     

       64
       65
        
       #[serde(tag = "error", content = "message")]

     

       65
       66
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       106
       107
        
                       Ok(())

     

       107
       108
        
                   }

     

       108
       109
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       109
       109
       -
               }

     

       110
       110
       -
           }

     

       111
       111
       -
       }

     

       112
       112
       -
       

     

       113
       113
       -
       impl jacquard_common::IntoStatic for ListBlobsError<'_> {

     

       114
       114
       -
           type Output = ListBlobsError<'static>;

     

       115
       115
       -
           fn into_static(self) -> Self::Output {

     

       116
       116
       -
               match self {

     

       117
       117
       -
                   ListBlobsError::RepoNotFound(v) => {

     

       118
       118
       -
                       ListBlobsError::RepoNotFound(v.into_static())

     

       119
       119
       -
                   }

     

       120
       120
       -
                   ListBlobsError::RepoTakendown(v) => {

     

       121
       121
       -
                       ListBlobsError::RepoTakendown(v.into_static())

     

       122
       122
       -
                   }

     

       123
       123
       -
                   ListBlobsError::RepoSuspended(v) => {

     

       124
       124
       -
                       ListBlobsError::RepoSuspended(v.into_static())

     

       125
       125
       -
                   }

     

       126
       126
       -
                   ListBlobsError::RepoDeactivated(v) => {

     

       127
       127
       -
                       ListBlobsError::RepoDeactivated(v.into_static())

     

       128
       128
       -
                   }

     

       129
       129
       -
                   ListBlobsError::Unknown(v) => ListBlobsError::Unknown(v.into_static()),

     

       130
       110
        
               }

     

       131
       111
        
           }

     

       132
       112
        
       }

+2 -13

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

···

       41
       41
        
           PartialEq,

     

       42
       42
        
           Eq,

     

       43
       43
        
           thiserror::Error,

     

       44
       44
       -
           miette::Diagnostic

     

       44
       44
       +
           miette::Diagnostic,

     

       45
       45
       +
           jacquard_derive::IntoStatic

     

       45
       46
        
       )]

     

       46
       47
        
       #[serde(tag = "error", content = "message")]

     

       47
       48
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       61
       62
        
                       Ok(())

     

       62
       63
        
                   }

     

       63
       64
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       64
       64
       -
               }

     

       65
       65
       -
           }

     

       66
       66
       -
       }

     

       67
       67
       -
       

     

       68
       68
       -
       impl jacquard_common::IntoStatic for RequestCrawlError<'_> {

     

       69
       69
       -
           type Output = RequestCrawlError<'static>;

     

       70
       70
       -
           fn into_static(self) -> Self::Output {

     

       71
       71
       -
               match self {

     

       72
       72
       -
                   RequestCrawlError::HostBanned(v) => {

     

       73
       73
       -
                       RequestCrawlError::HostBanned(v.into_static())

     

       74
       74
       -
                   }

     

       75
       75
       -
                   RequestCrawlError::Unknown(v) => RequestCrawlError::Unknown(v.into_static()),

     

       76
       65
        
               }

     

       77
       66
        
           }

     

       78
       67
        
       }

+2 -18

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

···

       166
       166
        
           PartialEq,

     

       167
       167
        
           Eq,

     

       168
       168
        
           thiserror::Error,

     

       169
       169
       -
           miette::Diagnostic

     

       169
       169
       +
           miette::Diagnostic,

     

       170
       170
       +
           jacquard_derive::IntoStatic

     

       170
       171
        
       )]

     

       171
       172
        
       #[serde(tag = "error", content = "message")]

     

       172
       173
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       196
       197
        
                       Ok(())

     

       197
       198
        
                   }

     

       198
       199
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       199
       199
       -
               }

     

       200
       200
       -
           }

     

       201
       201
       -
       }

     

       202
       202
       -
       

     

       203
       203
       -
       impl jacquard_common::IntoStatic for SubscribeReposError<'_> {

     

       204
       204
       -
           type Output = SubscribeReposError<'static>;

     

       205
       205
       -
           fn into_static(self) -> Self::Output {

     

       206
       206
       -
               match self {

     

       207
       207
       -
                   SubscribeReposError::FutureCursor(v) => {

     

       208
       208
       -
                       SubscribeReposError::FutureCursor(v.into_static())

     

       209
       209
       -
                   }

     

       210
       210
       -
                   SubscribeReposError::ConsumerTooSlow(v) => {

     

       211
       211
       -
                       SubscribeReposError::ConsumerTooSlow(v.into_static())

     

       212
       212
       -
                   }

     

       213
       213
       -
                   SubscribeReposError::Unknown(v) => {

     

       214
       214
       -
                       SubscribeReposError::Unknown(v.into_static())

     

       215
       215
       -
                   }

     

       216
       200
        
               }

     

       217
       201
        
           }

     

       218
       202
        
       }

+14 -17

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

···

       44
       44
        
           #[serde(borrow)]

     

       45
       45
        
           pub handle: jacquard_common::types::string::Handle<'a>,

     

       46
       46
        
           #[serde(borrow)]

     

       47
       47
       -
           pub result: CheckHandleAvailabilityOutputRecordResult<'a>,

     

       47
       47
       +
           pub result: CheckHandleAvailabilityOutputResult<'a>,

     

       48
       48
        
       }

     

       49
       49
        
       

     

       50
       50
        
       #[jacquard_derive::open_union]

     
···

       59
       59
        
       )]

     

       60
       60
        
       #[serde(tag = "$type")]

     

       61
       61
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       62
       62
       -
       pub enum CheckHandleAvailabilityOutputRecordResult<'a> {}

     

       62
       62
       +
       pub enum CheckHandleAvailabilityOutputResult<'a> {

     

       63
       63
       +
           #[serde(rename = "com.atproto.temp.checkHandleAvailability#resultAvailable")]

     

       64
       64
       +
           ResultAvailable(

     

       65
       65
       +
               Box<crate::com_atproto::temp::check_handle_availability::ResultAvailable<'a>>,

     

       66
       66
       +
           ),

     

       67
       67
       +
           #[serde(rename = "com.atproto.temp.checkHandleAvailability#resultUnavailable")]

     

       68
       68
       +
           ResultUnavailable(

     

       69
       69
       +
               Box<crate::com_atproto::temp::check_handle_availability::ResultUnavailable<'a>>,

     

       70
       70
       +
           ),

     

       71
       71
       +
       }

     

       72
       72
       +
       

     

       63
       73
        
       #[jacquard_derive::open_union]

     

       64
       74
        
       #[derive(

     

       65
       75
        
           serde::Serialize,

     
···

       69
       79
        
           PartialEq,

     

       70
       80
        
           Eq,

     

       71
       81
        
           thiserror::Error,

     

       72
       72
       -
           miette::Diagnostic

     

       82
       82
       +
           miette::Diagnostic,

     

       83
       83
       +
           jacquard_derive::IntoStatic

     

       73
       84
        
       )]

     

       74
       85
        
       #[serde(tag = "error", content = "message")]

     

       75
       86
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       90
       101
        
                       Ok(())

     

       91
       102
        
                   }

     

       92
       103
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       93
       93
       -
               }

     

       94
       94
       -
           }

     

       95
       95
       -
       }

     

       96
       96
       -
       

     

       97
       97
       -
       impl jacquard_common::IntoStatic for CheckHandleAvailabilityError<'_> {

     

       98
       98
       -
           type Output = CheckHandleAvailabilityError<'static>;

     

       99
       99
       -
           fn into_static(self) -> Self::Output {

     

       100
       100
       -
               match self {

     

       101
       101
       -
                   CheckHandleAvailabilityError::InvalidEmail(v) => {

     

       102
       102
       -
                       CheckHandleAvailabilityError::InvalidEmail(v.into_static())

     

       103
       103
       -
                   }

     

       104
       104
       -
                   CheckHandleAvailabilityError::Unknown(v) => {

     

       105
       105
       -
                       CheckHandleAvailabilityError::Unknown(v.into_static())

     

       106
       106
       -
                   }

     

       107
       104
        
               }

     

       108
       105
        
           }

     

       109
       106
        
       }

+2 -15

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

···

       49
       49
        
           PartialEq,

     

       50
       50
        
           Eq,

     

       51
       51
        
           thiserror::Error,

     

       52
       52
       -
           miette::Diagnostic

     

       52
       52
       +
           miette::Diagnostic,

     

       53
       53
       +
           jacquard_derive::IntoStatic

     

       53
       54
        
       )]

     

       54
       55
        
       #[serde(tag = "error", content = "message")]

     

       55
       56
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       70
       71
        
                       Ok(())

     

       71
       72
        
                   }

     

       72
       73
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       73
       73
       -
               }

     

       74
       74
       -
           }

     

       75
       75
       -
       }

     

       76
       76
       -
       

     

       77
       77
       -
       impl jacquard_common::IntoStatic for DereferenceScopeError<'_> {

     

       78
       78
       -
           type Output = DereferenceScopeError<'static>;

     

       79
       79
       -
           fn into_static(self) -> Self::Output {

     

       80
       80
       -
               match self {

     

       81
       81
       -
                   DereferenceScopeError::InvalidScopeReference(v) => {

     

       82
       82
       -
                       DereferenceScopeError::InvalidScopeReference(v.into_static())

     

       83
       83
       -
                   }

     

       84
       84
       -
                   DereferenceScopeError::Unknown(v) => {

     

       85
       85
       -
                       DereferenceScopeError::Unknown(v.into_static())

     

       86
       86
       -
                   }

     

       87
       74
        
               }

     

       88
       75
        
           }

     

       89
       76
        
       }

+2 -2

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

···

       40
       40
        
           #[serde(borrow)]

     

       41
       41
        
           pub children: Vec<crate::com_shinolabs::pinksea::app_view_defs::HydratedOekaki<'a>>,

     

       42
       42
        
           #[serde(borrow)]

     

       43
       43
       -
           pub parent: GetOekakiOutputRecordParent<'a>,

     

       43
       43
       +
           pub parent: GetOekakiOutputParent<'a>,

     

       44
       44
        
       }

     

       45
       45
        
       

     

       46
       46
        
       #[jacquard_derive::open_union]

     
···

       55
       55
        
       )]

     

       56
       56
        
       #[serde(tag = "$type")]

     

       57
       57
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       58
       58
       -
       pub enum GetOekakiOutputRecordParent<'a> {

     

       58
       58
       +
       pub enum GetOekakiOutputParent<'a> {

     

       59
       59
        
           #[serde(rename = "com.shinolabs.pinksea.appViewDefs#hydratedOekaki")]

     

       60
       60
        
           AppViewDefsHydratedOekaki(

     

       61
       61
        
               Box<crate::com_shinolabs::pinksea::app_view_defs::HydratedOekaki<'a>>,

+2 -15

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

···

       55
       55
        
           PartialEq,

     

       56
       56
        
           Eq,

     

       57
       57
        
           thiserror::Error,

     

       58
       58
       -
           miette::Diagnostic

     

       58
       58
       +
           miette::Diagnostic,

     

       59
       59
       +
           jacquard_derive::IntoStatic

     

       59
       60
        
       )]

     

       60
       61
        
       #[serde(tag = "error", content = "message")]

     

       61
       62
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       76
       77
        
                       Ok(())

     

       77
       78
        
                   }

     

       78
       79
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       79
       79
       -
               }

     

       80
       80
       -
           }

     

       81
       81
       -
       }

     

       82
       82
       -
       

     

       83
       83
       -
       impl jacquard_common::IntoStatic for GetEntryMetadataByNameError<'_> {

     

       84
       84
       -
           type Output = GetEntryMetadataByNameError<'static>;

     

       85
       85
       -
           fn into_static(self) -> Self::Output {

     

       86
       86
       -
               match self {

     

       87
       87
       -
                   GetEntryMetadataByNameError::NotFound(v) => {

     

       88
       88
       -
                       GetEntryMetadataByNameError::NotFound(v.into_static())

     

       89
       89
       -
                   }

     

       90
       90
       -
                   GetEntryMetadataByNameError::Unknown(v) => {

     

       91
       91
       -
                       GetEntryMetadataByNameError::Unknown(v.into_static())

     

       92
       92
       -
                   }

     

       93
       80
        
               }

     

       94
       81
        
           }

     

       95
       82
        
       }

+2 -12

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

···

       51
       51
        
           PartialEq,

     

       52
       52
        
           Eq,

     

       53
       53
        
           thiserror::Error,

     

       54
       54
       -
           miette::Diagnostic

     

       54
       54
       +
           miette::Diagnostic,

     

       55
       55
       +
           jacquard_derive::IntoStatic

     

       55
       56
        
       )]

     

       56
       57
        
       #[serde(tag = "error", content = "message")]

     

       57
       58
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       60
       61
        
           fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

     

       61
       62
        
               match self {

     

       62
       63
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       63
       63
       -
               }

     

       64
       64
       -
           }

     

       65
       65
       -
       }

     

       66
       66
       -
       

     

       67
       67
       -
       impl jacquard_common::IntoStatic for NotifyOfNewEntryError<'_> {

     

       68
       68
       -
           type Output = NotifyOfNewEntryError<'static>;

     

       69
       69
       -
           fn into_static(self) -> Self::Output {

     

       70
       70
       -
               match self {

     

       71
       71
       -
                   NotifyOfNewEntryError::Unknown(v) => {

     

       72
       72
       -
                       NotifyOfNewEntryError::Unknown(v.into_static())

     

       73
       73
       -
                   }

     

       74
       64
        
               }

     

       75
       65
        
           }

     

       76
       66
        
       }

+26 -1

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

···

       84
       84
        
           ///The locations where the event takes place.

     

       85
       85
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       86
       86
        
           #[serde(borrow)]

     

       87
       87
       -
           pub locations: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       87
       87
       +
           pub locations: std::option::Option<Vec<EventLocationsItem<'a>>>,

     

       88
       88
        
           ///The attendance mode of the event.

     

       89
       89
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       90
       90
        
           #[serde(borrow)]

     
···

       107
       107
        
           pub uris: std::option::Option<

     

       108
       108
        
               Vec<crate::community_lexicon::calendar::event::Uri<'a>>,

     

       109
       109
        
           >,

     

       110
       110
       +
       }

     

       111
       111
       +
       

     

       112
       112
       +
       #[jacquard_derive::open_union]

     

       113
       113
       +
       #[derive(

     

       114
       114
       +
           serde::Serialize,

     

       115
       115
       +
           serde::Deserialize,

     

       116
       116
       +
           Debug,

     

       117
       117
       +
           Clone,

     

       118
       118
       +
           PartialEq,

     

       119
       119
       +
           Eq,

     

       120
       120
       +
           jacquard_derive::IntoStatic

     

       121
       121
       +
       )]

     

       122
       122
       +
       #[serde(tag = "$type")]

     

       123
       123
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       124
       124
       +
       pub enum EventLocationsItem<'a> {

     

       125
       125
       +
           #[serde(rename = "community.lexicon.calendar.event#uri")]

     

       126
       126
       +
           Uri(Box<crate::community_lexicon::calendar::event::Uri<'a>>),

     

       127
       127
       +
           #[serde(rename = "community.lexicon.location.address")]

     

       128
       128
       +
           Address(Box<crate::community_lexicon::location::address::Address<'a>>),

     

       129
       129
       +
           #[serde(rename = "community.lexicon.location.fsq")]

     

       130
       130
       +
           Fsq(Box<crate::community_lexicon::location::fsq::Fsq<'a>>),

     

       131
       131
       +
           #[serde(rename = "community.lexicon.location.geo")]

     

       132
       132
       +
           Geo(Box<crate::community_lexicon::location::geo::Geo<'a>>),

     

       133
       133
       +
           #[serde(rename = "community.lexicon.location.hthree")]

     

       134
       134
       +
           Hthree(Box<crate::community_lexicon::location::hthree::Hthree<'a>>),

     

       110
       135
        
       }

     

       111
       136
        
       

     

       112
       137
        
       impl jacquard_common::types::collection::Collection for Event<'_> {

crates/jacquard-api/src/events_smokesignal.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       5
       +
       

     

       6
       6
       +
       pub mod automation;

crates/jacquard-api/src/events_smokesignal/automation.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       5
       +
       

     

       6
       6
       +
       pub mod invoke_webhook;

+78

crates/jacquard-api/src/events_smokesignal/automation/invoke_webhook.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: events.smokesignal.automation.InvokeWebhook

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           serde::Serialize,

     

       11
       11
       +
           serde::Deserialize,

     

       12
       12
       +
           Debug,

     

       13
       13
       +
           Clone,

     

       14
       14
       +
           PartialEq,

     

       15
       15
       +
           Eq,

     

       16
       16
       +
           bon::Builder,

     

       17
       17
       +
           jacquard_derive::IntoStatic

     

       18
       18
       +
       )]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       #[builder(start_fn = new)]

     

       21
       21
       +
       pub struct InvokeWebhook<'a> {

     

       22
       22
       +
           #[serde(borrow)]

     

       23
       23
       +
           pub context: InvokeWebhookContext<'a>,

     

       24
       24
       +
           #[serde(borrow)]

     

       25
       25
       +
           #[builder(into)]

     

       26
       26
       +
           pub event: jacquard_common::CowStr<'a>,

     

       27
       27
       +
           #[serde(borrow)]

     

       28
       28
       +
           pub record: InvokeWebhookRecord<'a>,

     

       29
       29
       +
           #[serde(flatten)]

     

       30
       30
       +
           #[serde(borrow)]

     

       31
       31
       +
           #[builder(default)]

     

       32
       32
       +
           pub extra_data: ::std::collections::BTreeMap<

     

       33
       33
       +
               ::jacquard_common::smol_str::SmolStr,

     

       34
       34
       +
               ::jacquard_common::types::value::Data<'a>,

     

       35
       35
       +
           >,

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       #[jacquard_derive::lexicon]

     

       39
       39
       +
       #[derive(

     

       40
       40
       +
           serde::Serialize,

     

       41
       41
       +
           serde::Deserialize,

     

       42
       42
       +
           Debug,

     

       43
       43
       +
           Clone,

     

       44
       44
       +
           PartialEq,

     

       45
       45
       +
           Eq,

     

       46
       46
       +
           jacquard_derive::IntoStatic

     

       47
       47
       +
       )]

     

       48
       48
       +
       #[serde(rename_all = "camelCase")]

     

       49
       49
       +
       pub struct InvokeWebhookOutput<'a> {}

     

       50
       50
       +
       ///Response type for

     

       51
       51
       +
       ///events.smokesignal.automation.InvokeWebhook

     

       52
       52
       +
       pub struct InvokeWebhookResponse;

     

       53
       53
       +
       impl jacquard_common::xrpc::XrpcResp for InvokeWebhookResponse {

     

       54
       54
       +
           const NSID: &'static str = "events.smokesignal.automation.InvokeWebhook";

     

       55
       55
       +
           const ENCODING: &'static str = "application/json";

     

       56
       56
       +
           type Output<'de> = InvokeWebhookOutput<'de>;

     

       57
       57
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       58
       58
       +
       }

     

       59
       59
       +
       

     

       60
       60
       +
       impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for InvokeWebhook<'de> {

     

       61
       61
       +
           const NSID: &'static str = "events.smokesignal.automation.InvokeWebhook";

     

       62
       62
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       63
       63
       +
               "application/json",

     

       64
       64
       +
           );

     

       65
       65
       +
           type Response = InvokeWebhookResponse;

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       ///Endpoint type for

     

       69
       69
       +
       ///events.smokesignal.automation.InvokeWebhook

     

       70
       70
       +
       pub struct InvokeWebhookRequest;

     

       71
       71
       +
       impl jacquard_common::xrpc::XrpcEndpoint for InvokeWebhookRequest {

     

       72
       72
       +
           const PATH: &'static str = "/xrpc/events.smokesignal.automation.InvokeWebhook";

     

       73
       73
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       74
       74
       +
               "application/json",

     

       75
       75
       +
           );

     

       76
       76
       +
           type Request<'de> = InvokeWebhook<'de>;

     

       77
       77
       +
           type Response = InvokeWebhookResponse;

     

       78
       78
       +
       }

+4 -1

crates/jacquard-api/src/lib.rs

···

       69
       69
        
       #[cfg(feature = "dev_regnault")]

     

       70
       70
        
       pub mod dev_regnault;

     

       71
       71
        
       

     

       72
       72
       +
       #[cfg(feature = "events_smokesignal")]

     

       73
       73
       +
       pub mod events_smokesignal;

     

       74
       74
       +
       

     

       72
       75
        
       #[cfg(feature = "fyi_unravel")]

     

       73
       76
        
       pub mod fyi_unravel;

     

       74
       77
        
       

     
···

       145
       148
        
       pub mod us_polhem;

     

       146
       149
        
       

     

       147
       150
        
       #[cfg(feature = "win_tomo_x")]

     

       148
       148
       -
       pub mod win_tomo_x;

     

       151
       151
       +
       pub mod win_tomo_x;

+11 -9

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

···

       37
       37
        
       pub struct Builtin<'a> {

     

       38
       38
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       39
       39
        
           #[serde(borrow)]

     

       40
       40
       -
           pub r#type: std::option::Option<BuiltinRecordType<'a>>,

     

       40
       40
       +
           pub r#type: std::option::Option<BuiltinType<'a>>,

     

       41
       41
        
       }

     

       42
       42
        
       

     

       43
       43
        
       #[jacquard_derive::open_union]

     
···

       52
       52
        
       )]

     

       53
       53
        
       #[serde(tag = "$type")]

     

       54
       54
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       55
       55
       -
       pub enum BuiltinRecordType<'a> {

     

       55
       55
       +
       pub enum BuiltinType<'a> {

     

       56
       56
        
           #[serde(rename = "my.skylights.listItem#inProgress")]

     

       57
       57
       -
           ListItemInProgress(Box<crate::my_skylights::list_item::InProgress>),

     

       57
       57
       +
           InProgress(Box<crate::my_skylights::list_item::InProgress>),

     

       58
       58
        
           #[serde(rename = "my.skylights.listItem#queue")]

     

       59
       59
       -
           ListItemQueue(Box<crate::my_skylights::list_item::Queue>),

     

       59
       59
       +
           Queue(Box<crate::my_skylights::list_item::Queue>),

     

       60
       60
        
           #[serde(rename = "my.skylights.listItem#abandoned")]

     

       61
       61
       -
           ListItemAbandoned(Box<crate::my_skylights::list_item::Abandoned>),

     

       61
       61
       +
           Abandoned(Box<crate::my_skylights::list_item::Abandoned>),

     

       62
       62
        
           #[serde(rename = "my.skylights.listItem#owned")]

     

       63
       63
       -
           ListItemOwned(Box<crate::my_skylights::list_item::Owned>),

     

       63
       63
       +
           Owned(Box<crate::my_skylights::list_item::Owned>),

     

       64
       64
        
           #[serde(rename = "my.skylights.listItem#wishlist")]

     

       65
       65
       -
           ListItemWishlist(Box<crate::my_skylights::list_item::Wishlist>),

     

       65
       65
       +
           Wishlist(Box<crate::my_skylights::list_item::Wishlist>),

     

       66
       66
        
       }

     

       67
       67
        
       

     

       68
       68
        
       ///User is currently reading/watching/... the item

     
···

       100
       100
        
           #[serde(borrow)]

     

       101
       101
        
           pub item: std::option::Option<crate::my_skylights::Item<'a>>,

     

       102
       102
        
           #[serde(borrow)]

     

       103
       103
       -
           pub list: ListItemRecordList<'a>,

     

       103
       103
       +
           pub list: ListItemList<'a>,

     

       104
       104
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       105
       105
        
           #[serde(borrow)]

     

       106
       106
        
           pub note: std::option::Option<jacquard_common::CowStr<'a>>,

     
···

       120
       120
        
       )]

     

       121
       121
        
       #[serde(tag = "$type")]

     

       122
       122
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       123
       123
       -
       pub enum ListItemRecordList<'a> {

     

       123
       123
       +
       pub enum ListItemList<'a> {

     

       124
       124
        
           #[serde(rename = "my.skylights.list")]

     

       125
       125
        
           List(Box<crate::my_skylights::list::List<'a>>),

     

       126
       126
       +
           #[serde(rename = "my.skylights.listItem#builtin")]

     

       127
       127
       +
           Builtin(Box<crate::my_skylights::list_item::Builtin<'a>>),

     

       126
       128
        
       }

     

       127
       129
        
       

     

       128
       130
        
       ///User owns the item

+3 -20

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

···

       22
       22
        
           pub created_at: jacquard_common::types::string::Datetime,

     

       23
       23
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       24
       24
        
           #[serde(borrow)]

     

       25
       25
       -
           pub embed: std::option::Option<DraftRecordEmbed<'a>>,

     

       25
       25
       +
           pub embed: std::option::Option<DraftEmbed<'a>>,

     

       26
       26
        
           ///Annotations of text (mentions, URLs, hashtags, etc)

     

       27
       27
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
        
           #[serde(borrow)]

     
···

       30
       30
        
           ///Self-label values for this post. Effectively content warnings.

     

       31
       31
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       32
       32
        
           #[serde(borrow)]

     

       33
       33
       -
           pub labels: std::option::Option<DraftRecordLabels<'a>>,

     

       33
       33
       +
           pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,

     

       34
       34
        
           ///Indicates human language of post primary text content.

     

       35
       35
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       36
       36
        
           pub langs: std::option::Option<Vec<jacquard_common::types::string::Language>>,

     
···

       61
       61
        
       )]

     

       62
       62
        
       #[serde(tag = "$type")]

     

       63
       63
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       64
       64
       -
       pub enum DraftRecordEmbed<'a> {

     

       64
       64
       +
       pub enum DraftEmbed<'a> {

     

       65
       65
        
           #[serde(rename = "app.bsky.embed.images")]

     

       66
       66
        
           Images(Box<crate::app_bsky::embed::images::Images<'a>>),

     

       67
       67
        
           #[serde(rename = "app.bsky.embed.video")]

     
···

       72
       72
        
           Record(Box<crate::app_bsky::embed::record::Record<'a>>),

     

       73
       73
        
           #[serde(rename = "app.bsky.embed.recordWithMedia")]

     

       74
       74
        
           RecordWithMedia(Box<crate::app_bsky::embed::record_with_media::RecordWithMedia<'a>>),

     

       75
       75
       -
       }

     

       76
       76
       -
       

     

       77
       77
       -
       #[jacquard_derive::open_union]

     

       78
       78
       -
       #[derive(

     

       79
       79
       -
           serde::Serialize,

     

       80
       80
       -
           serde::Deserialize,

     

       81
       81
       -
           Debug,

     

       82
       82
       -
           Clone,

     

       83
       83
       -
           PartialEq,

     

       84
       84
       -
           Eq,

     

       85
       85
       -
           jacquard_derive::IntoStatic

     

       86
       86
       -
       )]

     

       87
       87
       -
       #[serde(tag = "$type")]

     

       88
       88
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       89
       89
       -
       pub enum DraftRecordLabels<'a> {

     

       90
       90
       -
           #[serde(rename = "com.atproto.label.defs#selfLabels")]

     

       91
       91
       -
           DefsSelfLabels(Box<crate::com_atproto::label::SelfLabels<'a>>),

     

       92
       75
        
       }

     

       93
       76
        
       

     

       94
       77
        
       impl jacquard_common::types::collection::Collection for Draft<'_> {

+3 -20

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

···

       22
       22
        
           pub created_at: jacquard_common::types::string::Datetime,

     

       23
       23
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       24
       24
        
           #[serde(borrow)]

     

       25
       25
       -
           pub embed: std::option::Option<PostRecordEmbed<'a>>,

     

       25
       25
       +
           pub embed: std::option::Option<PostEmbed<'a>>,

     

       26
       26
        
           ///Annotations of text (mentions, URLs, hashtags, etc)

     

       27
       27
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
        
           #[serde(borrow)]

     
···

       30
       30
        
           ///Self-label values for this post. Effectively content warnings.

     

       31
       31
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       32
       32
        
           #[serde(borrow)]

     

       33
       33
       -
           pub labels: std::option::Option<PostRecordLabels<'a>>,

     

       33
       33
       +
           pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,

     

       34
       34
        
           ///Indicates human language of post primary text content.

     

       35
       35
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       36
       36
        
           pub langs: std::option::Option<Vec<jacquard_common::types::string::Language>>,

     
···

       58
       58
        
       )]

     

       59
       59
        
       #[serde(tag = "$type")]

     

       60
       60
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       61
       61
       -
       pub enum PostRecordEmbed<'a> {

     

       61
       61
       +
       pub enum PostEmbed<'a> {

     

       62
       62
        
           #[serde(rename = "app.bsky.embed.images")]

     

       63
       63
        
           Images(Box<crate::app_bsky::embed::images::Images<'a>>),

     

       64
       64
        
           #[serde(rename = "app.bsky.embed.video")]

     
···

       69
       69
        
           Record(Box<crate::app_bsky::embed::record::Record<'a>>),

     

       70
       70
        
           #[serde(rename = "app.bsky.embed.recordWithMedia")]

     

       71
       71
        
           RecordWithMedia(Box<crate::app_bsky::embed::record_with_media::RecordWithMedia<'a>>),

     

       72
       72
       -
       }

     

       73
       73
       -
       

     

       74
       74
       -
       #[jacquard_derive::open_union]

     

       75
       75
       -
       #[derive(

     

       76
       76
       -
           serde::Serialize,

     

       77
       77
       -
           serde::Deserialize,

     

       78
       78
       -
           Debug,

     

       79
       79
       -
           Clone,

     

       80
       80
       -
           PartialEq,

     

       81
       81
       -
           Eq,

     

       82
       82
       -
           jacquard_derive::IntoStatic

     

       83
       83
       -
       )]

     

       84
       84
       -
       #[serde(tag = "$type")]

     

       85
       85
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       86
       86
       -
       pub enum PostRecordLabels<'a> {

     

       87
       87
       -
           #[serde(rename = "com.atproto.label.defs#selfLabels")]

     

       88
       88
       -
           DefsSelfLabels(Box<crate::com_atproto::label::SelfLabels<'a>>),

     

       89
       72
        
       }

     

       90
       73
        
       

     

       91
       74
        
       impl jacquard_common::types::collection::Collection for Post<'_> {

+3 -1

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

···

       29
       29
        
           ///Verified signatures from endorsement proofs (strong references).

     

       30
       30
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       31
       31
        
           #[serde(borrow)]

     

       32
       32
       -
           pub signatures: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       32
       32
       +
           pub signatures: std::option::Option<

     

       33
       33
       +
               Vec<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,

     

       34
       34
       +
           >,

     

       33
       35
        
           ///The endorsement text content.

     

       34
       36
        
           #[serde(borrow)]

     

       35
       37
        
           pub text: jacquard_common::CowStr<'a>,

+2 -19

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

···

       58
       58
        
           PartialEq,

     

       59
       59
        
           Eq,

     

       60
       60
        
           thiserror::Error,

     

       61
       61
       -
           miette::Diagnostic

     

       61
       61
       +
           miette::Diagnostic,

     

       62
       62
       +
           jacquard_derive::IntoStatic

     

       62
       63
        
       )]

     

       63
       64
        
       #[serde(tag = "error", content = "message")]

     

       64
       65
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       99
       100
        
                       Ok(())

     

       100
       101
        
                   }

     

       101
       102
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       102
       102
       -
               }

     

       103
       103
       -
           }

     

       104
       104
       -
       }

     

       105
       105
       -
       

     

       106
       106
       -
       impl jacquard_common::IntoStatic for GetListingError<'_> {

     

       107
       107
       -
           type Output = GetListingError<'static>;

     

       108
       108
       -
           fn into_static(self) -> Self::Output {

     

       109
       109
       -
               match self {

     

       110
       110
       -
                   GetListingError::ListingNotFound(v) => {

     

       111
       111
       -
                       GetListingError::ListingNotFound(v.into_static())

     

       112
       112
       -
                   }

     

       113
       113
       -
                   GetListingError::ListingParseFailed(v) => {

     

       114
       114
       -
                       GetListingError::ListingParseFailed(v.into_static())

     

       115
       115
       -
                   }

     

       116
       116
       -
                   GetListingError::ListingFetchFailed(v) => {

     

       117
       117
       -
                       GetListingError::ListingFetchFailed(v.into_static())

     

       118
       118
       -
                   }

     

       119
       119
       -
                   GetListingError::Unknown(v) => GetListingError::Unknown(v.into_static()),

     

       120
       103
        
               }

     

       121
       104
        
           }

     

       122
       105
        
       }

+3 -1

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

···

       36
       36
        
           ///Locations that are relevant to the job listing.

     

       37
       37
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       38
       38
        
           #[serde(borrow)]

     

       39
       39
       -
           pub locations: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       39
       39
       +
           pub locations: std::option::Option<

     

       40
       40
       +
               Vec<crate::community_lexicon::location::hthree::Hthree<'a>>,

     

       41
       41
       +
           >,

     

       40
       42
        
           ///Client-declared timestamp when the job listing expires.

     

       41
       43
        
           pub not_after: jacquard_common::types::string::Datetime,

     

       42
       44
        
           ///Client-declared timestamp when the job listing becomes visible.

+2 -15

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

···

       73
       73
        
           PartialEq,

     

       74
       74
        
           Eq,

     

       75
       75
        
           thiserror::Error,

     

       76
       76
       -
           miette::Diagnostic

     

       76
       76
       +
           miette::Diagnostic,

     

       77
       77
       +
           jacquard_derive::IntoStatic

     

       77
       78
        
       )]

     

       78
       79
        
       #[serde(tag = "error", content = "message")]

     

       79
       80
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       94
       95
        
                       Ok(())

     

       95
       96
        
                   }

     

       96
       97
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       97
       97
       -
               }

     

       98
       98
       -
           }

     

       99
       99
       -
       }

     

       100
       100
       -
       

     

       101
       101
       -
       impl jacquard_common::IntoStatic for SearchListingsError<'_> {

     

       102
       102
       -
           type Output = SearchListingsError<'static>;

     

       103
       103
       -
           fn into_static(self) -> Self::Output {

     

       104
       104
       -
               match self {

     

       105
       105
       -
                   SearchListingsError::SearchFailed(v) => {

     

       106
       106
       -
                       SearchListingsError::SearchFailed(v.into_static())

     

       107
       107
       -
                   }

     

       108
       108
       -
                   SearchListingsError::Unknown(v) => {

     

       109
       109
       -
                       SearchListingsError::Unknown(v.into_static())

     

       110
       110
       -
                   }

     

       111
       98
        
               }

     

       112
       99
        
           }

     

       113
       100
        
       }

+3 -3

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

···

       38
       38
        
           pub record: jacquard_common::types::value::Data<'a>,

     

       39
       39
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       40
       40
        
           #[serde(borrow)]

     

       41
       41
       -
           pub reply_to: std::option::Option<MessageViewRecordReplyTo<'a>>,

     

       41
       41
       +
           pub reply_to: std::option::Option<MessageViewReplyTo<'a>>,

     

       42
       42
        
           #[serde(borrow)]

     

       43
       43
        
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       44
       44
        
       }

     
···

       55
       55
        
       )]

     

       56
       56
        
       #[serde(tag = "$type")]

     

       57
       57
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       58
       58
       -
       pub enum MessageViewRecordReplyTo<'a> {

     

       58
       58
       +
       pub enum MessageViewReplyTo<'a> {

     

       59
       59
        
           #[serde(rename = "place.stream.chat.defs#messageView")]

     

       60
       60
       -
           DefsMessageView(Box<crate::place_stream::chat::MessageView<'a>>),

     

       60
       60
       +
           MessageView(Box<crate::place_stream::chat::MessageView<'a>>),

     

       61
       61
        
       }

+2 -15

crates/jacquard-api/src/place_stream/live/get_profile_card.rs

···

       44
       44
        
           PartialEq,

     

       45
       45
        
           Eq,

     

       46
       46
        
           thiserror::Error,

     

       47
       47
       -
           miette::Diagnostic

     

       47
       47
       +
           miette::Diagnostic,

     

       48
       48
       +
           jacquard_derive::IntoStatic

     

       48
       49
        
       )]

     

       49
       50
        
       #[serde(tag = "error", content = "message")]

     

       50
       51
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       64
       65
        
                       Ok(())

     

       65
       66
        
                   }

     

       66
       67
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       67
       67
       -
               }

     

       68
       68
       -
           }

     

       69
       69
       -
       }

     

       70
       70
       -
       

     

       71
       71
       -
       impl jacquard_common::IntoStatic for GetProfileCardError<'_> {

     

       72
       72
       -
           type Output = GetProfileCardError<'static>;

     

       73
       73
       -
           fn into_static(self) -> Self::Output {

     

       74
       74
       -
               match self {

     

       75
       75
       -
                   GetProfileCardError::RepoNotFound(v) => {

     

       76
       76
       -
                       GetProfileCardError::RepoNotFound(v.into_static())

     

       77
       77
       -
                   }

     

       78
       78
       -
                   GetProfileCardError::Unknown(v) => {

     

       79
       79
       -
                       GetProfileCardError::Unknown(v.into_static())

     

       80
       80
       -
                   }

     

       81
       68
        
               }

     

       82
       69
        
           }

     

       83
       70
        
       }

+10 -6

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

···

       90
       90
        
       #[serde(rename_all = "camelCase")]

     

       91
       91
        
       pub struct StreamplaceAnything<'a> {

     

       92
       92
        
           #[serde(borrow)]

     

       93
       93
       -
           pub livestream: StreamplaceAnythingRecordLivestream<'a>,

     

       93
       93
       +
           pub livestream: StreamplaceAnythingLivestream<'a>,

     

       94
       94
        
       }

     

       95
       95
        
       

     

       96
       96
        
       #[jacquard_derive::open_union]

     
···

       105
       105
        
       )]

     

       106
       106
        
       #[serde(tag = "$type")]

     

       107
       107
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       108
       108
       -
       pub enum StreamplaceAnythingRecordLivestream<'a> {

     

       108
       108
       +
       pub enum StreamplaceAnythingLivestream<'a> {

     

       109
       109
       +
           #[serde(rename = "place.stream.livestream#livestreamView")]

     

       110
       110
       +
           LivestreamView(Box<crate::place_stream::livestream::LivestreamView<'a>>),

     

       111
       111
       +
           #[serde(rename = "place.stream.livestream#viewerCount")]

     

       112
       112
       +
           ViewerCount(Box<crate::place_stream::livestream::ViewerCount<'a>>),

     

       109
       113
        
           #[serde(rename = "place.stream.defs#blockView")]

     

       110
       110
       -
           DefsBlockView(Box<crate::place_stream::BlockView<'a>>),

     

       114
       114
       +
           BlockView(Box<crate::place_stream::BlockView<'a>>),

     

       111
       115
        
           #[serde(rename = "place.stream.defs#renditions")]

     

       112
       112
       -
           DefsRenditions(Box<crate::place_stream::Renditions<'a>>),

     

       116
       116
       +
           Renditions(Box<crate::place_stream::Renditions<'a>>),

     

       113
       117
        
           #[serde(rename = "place.stream.defs#rendition")]

     

       114
       114
       -
           DefsRendition(Box<crate::place_stream::Rendition<'a>>),

     

       118
       118
       +
           Rendition(Box<crate::place_stream::Rendition<'a>>),

     

       115
       119
        
           #[serde(rename = "place.stream.chat.defs#messageView")]

     

       116
       116
       -
           DefsMessageView(Box<crate::place_stream::chat::MessageView<'a>>),

     

       120
       120
       +
           MessageView(Box<crate::place_stream::chat::MessageView<'a>>),

     

       117
       121
        
       }

     

       118
       122
        
       

     

       119
       123
        
       #[jacquard_derive::lexicon]

+20 -1

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

···

       19
       19
        
       #[serde(rename_all = "camelCase")]

     

       20
       20
        
       pub struct Facet<'a> {

     

       21
       21
        
           #[serde(borrow)]

     

       22
       22
       -
           pub features: Vec<jacquard_common::types::value::Data<'a>>,

     

       22
       22
       +
           pub features: Vec<FacetFeaturesItem<'a>>,

     

       23
       23
        
           #[serde(borrow)]

     

       24
       24
        
           pub index: crate::app_bsky::richtext::facet::ByteSlice<'a>,

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       #[jacquard_derive::open_union]

     

       28
       28
       +
       #[derive(

     

       29
       29
       +
           serde::Serialize,

     

       30
       30
       +
           serde::Deserialize,

     

       31
       31
       +
           Debug,

     

       32
       32
       +
           Clone,

     

       33
       33
       +
           PartialEq,

     

       34
       34
       +
           Eq,

     

       35
       35
       +
           jacquard_derive::IntoStatic

     

       36
       36
       +
       )]

     

       37
       37
       +
       #[serde(tag = "$type")]

     

       38
       38
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       39
       39
       +
       pub enum FacetFeaturesItem<'a> {

     

       40
       40
       +
           #[serde(rename = "app.bsky.richtext.facet#mention")]

     

       41
       41
       +
           FacetMention(Box<crate::app_bsky::richtext::facet::Mention<'a>>),

     

       42
       42
       +
           #[serde(rename = "app.bsky.richtext.facet#link")]

     

       43
       43
       +
           FacetLink(Box<crate::app_bsky::richtext::facet::Link<'a>>),

     

       25
       44
        
       }

+2 -21

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

···

       86
       86
        
           PartialEq,

     

       87
       87
        
           Eq,

     

       88
       88
        
           thiserror::Error,

     

       89
       89
       -
           miette::Diagnostic

     

       89
       89
       +
           miette::Diagnostic,

     

       90
       90
       +
           jacquard_derive::IntoStatic

     

       90
       91
        
       )]

     

       91
       92
        
       #[serde(tag = "error", content = "message")]

     

       92
       93
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       127
       128
        
                       Ok(())

     

       128
       129
        
                   }

     

       129
       130
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       130
       130
       -
               }

     

       131
       131
       -
           }

     

       132
       132
       -
       }

     

       133
       133
       -
       

     

       134
       134
       -
       impl jacquard_common::IntoStatic for CreateWebhookError<'_> {

     

       135
       135
       -
           type Output = CreateWebhookError<'static>;

     

       136
       136
       -
           fn into_static(self) -> Self::Output {

     

       137
       137
       -
               match self {

     

       138
       138
       -
                   CreateWebhookError::InvalidUrl(v) => {

     

       139
       139
       -
                       CreateWebhookError::InvalidUrl(v.into_static())

     

       140
       140
       -
                   }

     

       141
       141
       -
                   CreateWebhookError::DuplicateWebhook(v) => {

     

       142
       142
       -
                       CreateWebhookError::DuplicateWebhook(v.into_static())

     

       143
       143
       -
                   }

     

       144
       144
       -
                   CreateWebhookError::TooManyWebhooks(v) => {

     

       145
       145
       -
                       CreateWebhookError::TooManyWebhooks(v.into_static())

     

       146
       146
       -
                   }

     

       147
       147
       -
                   CreateWebhookError::Unknown(v) => {

     

       148
       148
       -
                       CreateWebhookError::Unknown(v.into_static())

     

       149
       149
       -
                   }

     

       150
       131
        
               }

     

       151
       132
        
           }

     

       152
       133
        
       }

+2 -18

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

···

       57
       57
        
           PartialEq,

     

       58
       58
        
           Eq,

     

       59
       59
        
           thiserror::Error,

     

       60
       60
       -
           miette::Diagnostic

     

       60
       60
       +
           miette::Diagnostic,

     

       61
       61
       +
           jacquard_derive::IntoStatic

     

       61
       62
        
       )]

     

       62
       63
        
       #[serde(tag = "error", content = "message")]

     

       63
       64
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       88
       89
        
                       Ok(())

     

       89
       90
        
                   }

     

       90
       91
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       91
       91
       -
               }

     

       92
       92
       -
           }

     

       93
       93
       -
       }

     

       94
       94
       -
       

     

       95
       95
       -
       impl jacquard_common::IntoStatic for DeleteWebhookError<'_> {

     

       96
       96
       -
           type Output = DeleteWebhookError<'static>;

     

       97
       97
       -
           fn into_static(self) -> Self::Output {

     

       98
       98
       -
               match self {

     

       99
       99
       -
                   DeleteWebhookError::WebhookNotFound(v) => {

     

       100
       100
       -
                       DeleteWebhookError::WebhookNotFound(v.into_static())

     

       101
       101
       -
                   }

     

       102
       102
       -
                   DeleteWebhookError::Unauthorized(v) => {

     

       103
       103
       -
                       DeleteWebhookError::Unauthorized(v.into_static())

     

       104
       104
       -
                   }

     

       105
       105
       -
                   DeleteWebhookError::Unknown(v) => {

     

       106
       106
       -
                       DeleteWebhookError::Unknown(v.into_static())

     

       107
       107
       -
                   }

     

       108
       92
        
               }

     

       109
       93
        
           }

     

       110
       94
        
       }

+2 -16

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

···

       48
       48
        
           PartialEq,

     

       49
       49
        
           Eq,

     

       50
       50
        
           thiserror::Error,

     

       51
       51
       -
           miette::Diagnostic

     

       51
       51
       +
           miette::Diagnostic,

     

       52
       52
       +
           jacquard_derive::IntoStatic

     

       52
       53
        
       )]

     

       53
       54
        
       #[serde(tag = "error", content = "message")]

     

       54
       55
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       79
       80
        
                       Ok(())

     

       80
       81
        
                   }

     

       81
       82
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       82
       82
       -
               }

     

       83
       83
       -
           }

     

       84
       84
       -
       }

     

       85
       85
       -
       

     

       86
       86
       -
       impl jacquard_common::IntoStatic for GetWebhookError<'_> {

     

       87
       87
       -
           type Output = GetWebhookError<'static>;

     

       88
       88
       -
           fn into_static(self) -> Self::Output {

     

       89
       89
       -
               match self {

     

       90
       90
       -
                   GetWebhookError::WebhookNotFound(v) => {

     

       91
       91
       -
                       GetWebhookError::WebhookNotFound(v.into_static())

     

       92
       92
       -
                   }

     

       93
       93
       -
                   GetWebhookError::Unauthorized(v) => {

     

       94
       94
       -
                       GetWebhookError::Unauthorized(v.into_static())

     

       95
       95
       -
                   }

     

       96
       96
       -
                   GetWebhookError::Unknown(v) => GetWebhookError::Unknown(v.into_static()),

     

       97
       83
        
               }

     

       98
       84
        
           }

     

       99
       85
        
       }

+2 -13

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

···

       62
       62
        
           PartialEq,

     

       63
       63
        
           Eq,

     

       64
       64
        
           thiserror::Error,

     

       65
       65
       -
           miette::Diagnostic

     

       65
       65
       +
           miette::Diagnostic,

     

       66
       66
       +
           jacquard_derive::IntoStatic

     

       66
       67
        
       )]

     

       67
       68
        
       #[serde(tag = "error", content = "message")]

     

       68
       69
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       83
       84
        
                       Ok(())

     

       84
       85
        
                   }

     

       85
       86
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       86
       86
       -
               }

     

       87
       87
       -
           }

     

       88
       88
       -
       }

     

       89
       89
       -
       

     

       90
       90
       -
       impl jacquard_common::IntoStatic for ListWebhooksError<'_> {

     

       91
       91
       -
           type Output = ListWebhooksError<'static>;

     

       92
       92
       -
           fn into_static(self) -> Self::Output {

     

       93
       93
       -
               match self {

     

       94
       94
       -
                   ListWebhooksError::InvalidCursor(v) => {

     

       95
       95
       -
                       ListWebhooksError::InvalidCursor(v.into_static())

     

       96
       96
       -
                   }

     

       97
       97
       -
                   ListWebhooksError::Unknown(v) => ListWebhooksError::Unknown(v.into_static()),

     

       98
       87
        
               }

     

       99
       88
        
           }

     

       100
       89
        
       }

+2 -24

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

···

       92
       92
        
           PartialEq,

     

       93
       93
        
           Eq,

     

       94
       94
        
           thiserror::Error,

     

       95
       95
       -
           miette::Diagnostic

     

       95
       95
       +
           miette::Diagnostic,

     

       96
       96
       +
           jacquard_derive::IntoStatic

     

       96
       97
        
       )]

     

       97
       98
        
       #[serde(tag = "error", content = "message")]

     

       98
       99
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       143
       144
        
                       Ok(())

     

       144
       145
        
                   }

     

       145
       146
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       146
       146
       -
               }

     

       147
       147
       -
           }

     

       148
       148
       -
       }

     

       149
       149
       -
       

     

       150
       150
       -
       impl jacquard_common::IntoStatic for UpdateWebhookError<'_> {

     

       151
       151
       -
           type Output = UpdateWebhookError<'static>;

     

       152
       152
       -
           fn into_static(self) -> Self::Output {

     

       153
       153
       -
               match self {

     

       154
       154
       -
                   UpdateWebhookError::WebhookNotFound(v) => {

     

       155
       155
       -
                       UpdateWebhookError::WebhookNotFound(v.into_static())

     

       156
       156
       -
                   }

     

       157
       157
       -
                   UpdateWebhookError::Unauthorized(v) => {

     

       158
       158
       -
                       UpdateWebhookError::Unauthorized(v.into_static())

     

       159
       159
       -
                   }

     

       160
       160
       -
                   UpdateWebhookError::InvalidUrl(v) => {

     

       161
       161
       -
                       UpdateWebhookError::InvalidUrl(v.into_static())

     

       162
       162
       -
                   }

     

       163
       163
       -
                   UpdateWebhookError::DuplicateWebhook(v) => {

     

       164
       164
       -
                       UpdateWebhookError::DuplicateWebhook(v.into_static())

     

       165
       165
       -
                   }

     

       166
       166
       -
                   UpdateWebhookError::Unknown(v) => {

     

       167
       167
       -
                       UpdateWebhookError::Unknown(v.into_static())

     

       168
       168
       -
                   }

     

       169
       147
        
               }

     

       170
       148
        
           }

     

       171
       149
        
       }

+2 -2

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

···

       23
       23
        
               Vec<crate::pub_leaflet::blocks::unordered_list::ListItem<'a>>,

     

       24
       24
        
           >,

     

       25
       25
        
           #[serde(borrow)]

     

       26
       26
       -
           pub content: ListItemRecordContent<'a>,

     

       26
       26
       +
           pub content: ListItemContent<'a>,

     

       27
       27
        
       }

     

       28
       28
        
       

     

       29
       29
        
       #[jacquard_derive::open_union]

     
···

       38
       38
        
       )]

     

       39
       39
        
       #[serde(tag = "$type")]

     

       40
       40
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       41
       41
       -
       pub enum ListItemRecordContent<'a> {

     

       41
       41
       +
       pub enum ListItemContent<'a> {

     

       42
       42
        
           #[serde(rename = "pub.leaflet.blocks.text")]

     

       43
       43
        
           Text(Box<crate::pub_leaflet::blocks::text::Text<'a>>),

     

       44
       44
        
           #[serde(rename = "pub.leaflet.blocks.header")]

+3 -14

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

···

       38
       38
        
       pub struct Comment<'a> {

     

       39
       39
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       40
       40
        
           #[serde(borrow)]

     

       41
       41
       -
           pub attachment: std::option::Option<CommentRecordAttachment<'a>>,

     

       41
       41
       +
           pub attachment: std::option::Option<

     

       42
       42
       +
               crate::pub_leaflet::comment::LinearDocumentQuote<'a>,

     

       43
       43
       +
           >,

     

       42
       44
        
           pub created_at: jacquard_common::types::string::Datetime,

     

       43
       45
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       44
       46
        
           #[serde(borrow)]

     
···

       52
       54
        
           pub subject: jacquard_common::types::string::AtUri<'a>,

     

       53
       55
        
       }

     

       54
       56
        
       

     

       55
       55
       -
       #[jacquard_derive::open_union]

     

       56
       56
       -
       #[derive(

     

       57
       57
       -
           serde::Serialize,

     

       58
       58
       -
           serde::Deserialize,

     

       59
       59
       -
           Debug,

     

       60
       60
       -
           Clone,

     

       61
       61
       -
           PartialEq,

     

       62
       62
       -
           Eq,

     

       63
       63
       -
           jacquard_derive::IntoStatic

     

       64
       64
       -
       )]

     

       65
       65
       -
       #[serde(tag = "$type")]

     

       66
       66
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       67
       67
       -
       pub enum CommentRecordAttachment<'a> {}

     

       68
       57
        
       impl jacquard_common::types::collection::Collection for Comment<'_> {

     

       69
       58
        
           const NSID: &'static str = "pub.leaflet.comment";

     

       70
       59
        
       }

+1 -1

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

···

       24
       24
        
           #[serde(borrow)]

     

       25
       25
        
           pub description: std::option::Option<jacquard_common::CowStr<'a>>,

     

       26
       26
        
           #[serde(borrow)]

     

       27
       27
       -
           pub pages: Vec<jacquard_common::types::value::Data<'a>>,

     

       27
       27
       +
           pub pages: Vec<crate::pub_leaflet::pages::linear_document::LinearDocument<'a>>,

     

       28
       28
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       29
       29
        
           #[serde(borrow)]

     

       30
       30
        
           pub post_ref: std::option::Option<

+2 -2

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

···

       21
       21
        
           #[serde(borrow)]

     

       22
       22
        
           pub alignment: std::option::Option<jacquard_common::CowStr<'a>>,

     

       23
       23
        
           #[serde(borrow)]

     

       24
       24
       -
           pub block: BlockRecordBlock<'a>,

     

       24
       24
       +
           pub block: BlockBlock<'a>,

     

       25
       25
        
       }

     

       26
       26
        
       

     

       27
       27
        
       #[jacquard_derive::open_union]

     
···

       36
       36
        
       )]

     

       37
       37
        
       #[serde(tag = "$type")]

     

       38
       38
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       39
       39
       -
       pub enum BlockRecordBlock<'a> {

     

       39
       39
       +
       pub enum BlockBlock<'a> {

     

       40
       40
        
           #[serde(rename = "pub.leaflet.blocks.iframe")]

     

       41
       41
        
           Iframe(Box<crate::pub_leaflet::blocks::iframe::Iframe<'a>>),

     

       42
       42
        
           #[serde(rename = "pub.leaflet.blocks.text")]

+10 -10

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

···

       75
       75
        
       pub struct Theme<'a> {

     

       76
       76
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       77
       77
        
           #[serde(borrow)]

     

       78
       78
       -
           pub accent_background: std::option::Option<ThemeRecordAccentBackground<'a>>,

     

       78
       78
       +
           pub accent_background: std::option::Option<ThemeAccentBackground<'a>>,

     

       79
       79
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       80
       80
        
           #[serde(borrow)]

     

       81
       81
       -
           pub accent_text: std::option::Option<ThemeRecordAccentText<'a>>,

     

       81
       81
       +
           pub accent_text: std::option::Option<ThemeAccentText<'a>>,

     

       82
       82
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       83
       83
        
           #[serde(borrow)]

     

       84
       84
       -
           pub background_color: std::option::Option<ThemeRecordBackgroundColor<'a>>,

     

       84
       84
       +
           pub background_color: std::option::Option<ThemeBackgroundColor<'a>>,

     

       85
       85
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       86
       86
        
           #[serde(borrow)]

     

       87
       87
        
           pub background_image: std::option::Option<

     
···

       89
       89
        
           >,

     

       90
       90
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       91
       91
        
           #[serde(borrow)]

     

       92
       92
       -
           pub page_background: std::option::Option<ThemeRecordPageBackground<'a>>,

     

       92
       92
       +
           pub page_background: std::option::Option<ThemePageBackground<'a>>,

     

       93
       93
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       94
       94
        
           #[serde(borrow)]

     

       95
       95
       -
           pub primary: std::option::Option<ThemeRecordPrimary<'a>>,

     

       95
       95
       +
           pub primary: std::option::Option<ThemePrimary<'a>>,

     

       96
       96
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       97
       97
        
           pub show_page_background: std::option::Option<bool>,

     

       98
       98
        
       }

     
···

       109
       109
        
       )]

     

       110
       110
        
       #[serde(tag = "$type")]

     

       111
       111
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       112
       112
       -
       pub enum ThemeRecordAccentBackground<'a> {

     

       112
       112
       +
       pub enum ThemeAccentBackground<'a> {

     

       113
       113
        
           #[serde(rename = "pub.leaflet.theme.color#rgba")]

     

       114
       114
        
           ColorRgba(Box<crate::pub_leaflet::theme::color::Rgba<'a>>),

     

       115
       115
        
           #[serde(rename = "pub.leaflet.theme.color#rgb")]

     
···

       128
       128
        
       )]

     

       129
       129
        
       #[serde(tag = "$type")]

     

       130
       130
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       131
       131
       -
       pub enum ThemeRecordAccentText<'a> {

     

       131
       131
       +
       pub enum ThemeAccentText<'a> {

     

       132
       132
        
           #[serde(rename = "pub.leaflet.theme.color#rgba")]

     

       133
       133
        
           ColorRgba(Box<crate::pub_leaflet::theme::color::Rgba<'a>>),

     

       134
       134
        
           #[serde(rename = "pub.leaflet.theme.color#rgb")]

     
···

       147
       147
        
       )]

     

       148
       148
        
       #[serde(tag = "$type")]

     

       149
       149
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       150
       150
       -
       pub enum ThemeRecordBackgroundColor<'a> {

     

       150
       150
       +
       pub enum ThemeBackgroundColor<'a> {

     

       151
       151
        
           #[serde(rename = "pub.leaflet.theme.color#rgba")]

     

       152
       152
        
           ColorRgba(Box<crate::pub_leaflet::theme::color::Rgba<'a>>),

     

       153
       153
        
           #[serde(rename = "pub.leaflet.theme.color#rgb")]

     
···

       166
       166
        
       )]

     

       167
       167
        
       #[serde(tag = "$type")]

     

       168
       168
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       169
       169
       -
       pub enum ThemeRecordPageBackground<'a> {

     

       169
       169
       +
       pub enum ThemePageBackground<'a> {

     

       170
       170
        
           #[serde(rename = "pub.leaflet.theme.color#rgba")]

     

       171
       171
        
           ColorRgba(Box<crate::pub_leaflet::theme::color::Rgba<'a>>),

     

       172
       172
        
           #[serde(rename = "pub.leaflet.theme.color#rgb")]

     
···

       185
       185
        
       )]

     

       186
       186
        
       #[serde(tag = "$type")]

     

       187
       187
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       188
       188
       -
       pub enum ThemeRecordPrimary<'a> {

     

       188
       188
       +
       pub enum ThemePrimary<'a> {

     

       189
       189
        
           #[serde(rename = "pub.leaflet.theme.color#rgba")]

     

       190
       190
        
           ColorRgba(Box<crate::pub_leaflet::theme::color::Rgba<'a>>),

     

       191
       191
        
           #[serde(rename = "pub.leaflet.theme.color#rgb")]

+32 -1

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

···

       123
       123
        
       #[serde(rename_all = "camelCase")]

     

       124
       124
        
       pub struct Facet<'a> {

     

       125
       125
        
           #[serde(borrow)]

     

       126
       126
       -
           pub features: Vec<jacquard_common::types::value::Data<'a>>,

     

       126
       126
       +
           pub features: Vec<FacetFeaturesItem<'a>>,

     

       127
       127
        
           #[serde(borrow)]

     

       128
       128
        
           pub index: crate::pub_leaflet::richtext::facet::ByteSlice<'a>,

     

       129
       129
       +
       }

     

       130
       130
       +
       

     

       131
       131
       +
       #[jacquard_derive::open_union]

     

       132
       132
       +
       #[derive(

     

       133
       133
       +
           serde::Serialize,

     

       134
       134
       +
           serde::Deserialize,

     

       135
       135
       +
           Debug,

     

       136
       136
       +
           Clone,

     

       137
       137
       +
           PartialEq,

     

       138
       138
       +
           Eq,

     

       139
       139
       +
           jacquard_derive::IntoStatic

     

       140
       140
       +
       )]

     

       141
       141
       +
       #[serde(tag = "$type")]

     

       142
       142
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       143
       143
       +
       pub enum FacetFeaturesItem<'a> {

     

       144
       144
       +
           #[serde(rename = "pub.leaflet.richtext.facet#link")]

     

       145
       145
       +
           Link(Box<crate::pub_leaflet::richtext::facet::Link<'a>>),

     

       146
       146
       +
           #[serde(rename = "pub.leaflet.richtext.facet#code")]

     

       147
       147
       +
           Code(Box<crate::pub_leaflet::richtext::facet::Code<'a>>),

     

       148
       148
       +
           #[serde(rename = "pub.leaflet.richtext.facet#highlight")]

     

       149
       149
       +
           Highlight(Box<crate::pub_leaflet::richtext::facet::Highlight<'a>>),

     

       150
       150
       +
           #[serde(rename = "pub.leaflet.richtext.facet#underline")]

     

       151
       151
       +
           Underline(Box<crate::pub_leaflet::richtext::facet::Underline<'a>>),

     

       152
       152
       +
           #[serde(rename = "pub.leaflet.richtext.facet#strikethrough")]

     

       153
       153
       +
           Strikethrough(Box<crate::pub_leaflet::richtext::facet::Strikethrough<'a>>),

     

       154
       154
       +
           #[serde(rename = "pub.leaflet.richtext.facet#id")]

     

       155
       155
       +
           Id(Box<crate::pub_leaflet::richtext::facet::Id<'a>>),

     

       156
       156
       +
           #[serde(rename = "pub.leaflet.richtext.facet#bold")]

     

       157
       157
       +
           Bold(Box<crate::pub_leaflet::richtext::facet::Bold<'a>>),

     

       158
       158
       +
           #[serde(rename = "pub.leaflet.richtext.facet#italic")]

     

       159
       159
       +
           Italic(Box<crate::pub_leaflet::richtext::facet::Italic<'a>>),

     

       129
       160
        
       }

     

       130
       161
        
       

     

       131
       162
        
       ///Facet feature for strikethrough markup

+2 -13

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

···

       56
       56
        
           PartialEq,

     

       57
       57
        
           Eq,

     

       58
       58
        
           thiserror::Error,

     

       59
       59
       -
           miette::Diagnostic

     

       59
       59
       +
           miette::Diagnostic,

     

       60
       60
       +
           jacquard_derive::IntoStatic

     

       60
       61
        
       )]

     

       61
       62
        
       #[serde(tag = "error", content = "message")]

     

       62
       63
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       77
       78
        
                       Ok(())

     

       78
       79
        
                   }

     

       79
       80
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       80
       80
       -
               }

     

       81
       81
       -
           }

     

       82
       82
       -
       }

     

       83
       83
       -
       

     

       84
       84
       -
       impl jacquard_common::IntoStatic for ListKeysError<'_> {

     

       85
       85
       -
           type Output = ListKeysError<'static>;

     

       86
       86
       -
           fn into_static(self) -> Self::Output {

     

       87
       87
       -
               match self {

     

       88
       88
       -
                   ListKeysError::InternalServerError(v) => {

     

       89
       89
       -
                       ListKeysError::InternalServerError(v.into_static())

     

       90
       90
       -
                   }

     

       91
       91
       -
                   ListKeysError::Unknown(v) => ListKeysError::Unknown(v.into_static()),

     

       92
       81
        
               }

     

       93
       82
        
           }

     

       94
       83
        
       }

+2 -10

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

···

       30
       30
        
           PartialEq,

     

       31
       31
        
           Eq,

     

       32
       32
        
           thiserror::Error,

     

       33
       33
       -
           miette::Diagnostic

     

       33
       33
       +
           miette::Diagnostic,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       34
       35
        
       )]

     

       35
       36
        
       #[serde(tag = "error", content = "message")]

     

       36
       37
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       39
       40
        
           fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

     

       40
       41
        
               match self {

     

       41
       42
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       42
       42
       -
               }

     

       43
       43
       -
           }

     

       44
       44
       -
       }

     

       45
       45
       -
       

     

       46
       46
       -
       impl jacquard_common::IntoStatic for VersionError<'_> {

     

       47
       47
       -
           type Output = VersionError<'static>;

     

       48
       48
       -
           fn into_static(self) -> Self::Output {

     

       49
       49
       -
               match self {

     

       50
       50
       -
                   VersionError::Unknown(v) => VersionError::Unknown(v.into_static()),

     

       51
       43
        
               }

     

       52
       44
        
           }

     

       53
       45
        
       }

+2 -11

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

···

       30
       30
        
           PartialEq,

     

       31
       31
        
           Eq,

     

       32
       32
        
           thiserror::Error,

     

       33
       33
       -
           miette::Diagnostic

     

       33
       33
       +
           miette::Diagnostic,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       34
       35
        
       )]

     

       35
       36
        
       #[serde(tag = "error", content = "message")]

     

       36
       37
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       51
       52
        
                       Ok(())

     

       52
       53
        
                   }

     

       53
       54
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       54
       54
       -
               }

     

       55
       55
       -
           }

     

       56
       56
       -
       }

     

       57
       57
       -
       

     

       58
       58
       -
       impl jacquard_common::IntoStatic for OwnerError<'_> {

     

       59
       59
       -
           type Output = OwnerError<'static>;

     

       60
       60
       -
           fn into_static(self) -> Self::Output {

     

       61
       61
       -
               match self {

     

       62
       62
       -
                   OwnerError::OwnerNotFound(v) => OwnerError::OwnerNotFound(v.into_static()),

     

       63
       63
       -
                   OwnerError::Unknown(v) => OwnerError::Unknown(v.into_static()),

     

       64
       55
        
               }

     

       65
       56
        
           }

     

       66
       57
        
       }

+2 -16

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

···

       57
       57
        
           PartialEq,

     

       58
       58
        
           Eq,

     

       59
       59
        
           thiserror::Error,

     

       60
       60
       -
           miette::Diagnostic

     

       60
       60
       +
           miette::Diagnostic,

     

       61
       61
       +
           jacquard_derive::IntoStatic

     

       61
       62
        
       )]

     

       62
       63
        
       #[serde(tag = "error", content = "message")]

     

       63
       64
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       108
       109
        
                       Ok(())

     

       109
       110
        
                   }

     

       110
       111
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       111
       111
       -
               }

     

       112
       112
       -
           }

     

       113
       113
       -
       }

     

       114
       114
       -
       

     

       115
       115
       -
       impl jacquard_common::IntoStatic for ArchiveError<'_> {

     

       116
       116
       -
           type Output = ArchiveError<'static>;

     

       117
       117
       -
           fn into_static(self) -> Self::Output {

     

       118
       118
       -
               match self {

     

       119
       119
       -
                   ArchiveError::RepoNotFound(v) => ArchiveError::RepoNotFound(v.into_static()),

     

       120
       120
       -
                   ArchiveError::RefNotFound(v) => ArchiveError::RefNotFound(v.into_static()),

     

       121
       121
       -
                   ArchiveError::InvalidRequest(v) => {

     

       122
       122
       -
                       ArchiveError::InvalidRequest(v.into_static())

     

       123
       123
       -
                   }

     

       124
       124
       -
                   ArchiveError::ArchiveError(v) => ArchiveError::ArchiveError(v.into_static()),

     

       125
       125
       -
                   ArchiveError::Unknown(v) => ArchiveError::Unknown(v.into_static()),

     

       126
       112
        
               }

     

       127
       113
        
           }

     

       128
       114
        
       }

+2 -14

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

···

       110
       110
        
           PartialEq,

     

       111
       111
        
           Eq,

     

       112
       112
        
           thiserror::Error,

     

       113
       113
       -
           miette::Diagnostic

     

       113
       113
       +
           miette::Diagnostic,

     

       114
       114
       +
           jacquard_derive::IntoStatic

     

       114
       115
        
       )]

     

       115
       116
        
       #[serde(tag = "error", content = "message")]

     

       116
       117
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       161
       162
        
                       Ok(())

     

       162
       163
        
                   }

     

       163
       164
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       164
       164
       -
               }

     

       165
       165
       -
           }

     

       166
       166
       -
       }

     

       167
       167
       -
       

     

       168
       168
       -
       impl jacquard_common::IntoStatic for BlobError<'_> {

     

       169
       169
       -
           type Output = BlobError<'static>;

     

       170
       170
       -
           fn into_static(self) -> Self::Output {

     

       171
       171
       -
               match self {

     

       172
       172
       -
                   BlobError::RepoNotFound(v) => BlobError::RepoNotFound(v.into_static()),

     

       173
       173
       -
                   BlobError::RefNotFound(v) => BlobError::RefNotFound(v.into_static()),

     

       174
       174
       -
                   BlobError::FileNotFound(v) => BlobError::FileNotFound(v.into_static()),

     

       175
       175
       -
                   BlobError::InvalidRequest(v) => BlobError::InvalidRequest(v.into_static()),

     

       176
       176
       -
                   BlobError::Unknown(v) => BlobError::Unknown(v.into_static()),

     

       177
       165
        
               }

     

       178
       166
        
           }

     

       179
       167
        
       }

+2 -17

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

···

       71
       71
        
           PartialEq,

     

       72
       72
        
           Eq,

     

       73
       73
        
           thiserror::Error,

     

       74
       74
       -
           miette::Diagnostic

     

       74
       74
       +
           miette::Diagnostic,

     

       75
       75
       +
           jacquard_derive::IntoStatic

     

       75
       76
        
       )]

     

       76
       77
        
       #[serde(tag = "error", content = "message")]

     

       77
       78
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       112
       113
        
                       Ok(())

     

       113
       114
        
                   }

     

       114
       115
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       115
       115
       -
               }

     

       116
       116
       -
           }

     

       117
       117
       -
       }

     

       118
       118
       -
       

     

       119
       119
       -
       impl jacquard_common::IntoStatic for BranchError<'_> {

     

       120
       120
       -
           type Output = BranchError<'static>;

     

       121
       121
       -
           fn into_static(self) -> Self::Output {

     

       122
       122
       -
               match self {

     

       123
       123
       -
                   BranchError::RepoNotFound(v) => BranchError::RepoNotFound(v.into_static()),

     

       124
       124
       -
                   BranchError::BranchNotFound(v) => {

     

       125
       125
       -
                       BranchError::BranchNotFound(v.into_static())

     

       126
       126
       -
                   }

     

       127
       127
       -
                   BranchError::InvalidRequest(v) => {

     

       128
       128
       -
                       BranchError::InvalidRequest(v.into_static())

     

       129
       129
       -
                   }

     

       130
       130
       -
                   BranchError::Unknown(v) => BranchError::Unknown(v.into_static()),

     

       131
       116
        
               }

     

       132
       117
        
           }

     

       133
       118
        
       }

+2 -16

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

···

       51
       51
        
           PartialEq,

     

       52
       52
        
           Eq,

     

       53
       53
        
           thiserror::Error,

     

       54
       54
       -
           miette::Diagnostic

     

       54
       54
       +
           miette::Diagnostic,

     

       55
       55
       +
           jacquard_derive::IntoStatic

     

       55
       56
        
       )]

     

       56
       57
        
       #[serde(tag = "error", content = "message")]

     

       57
       58
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       82
       83
        
                       Ok(())

     

       83
       84
        
                   }

     

       84
       85
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       85
       85
       -
               }

     

       86
       86
       -
           }

     

       87
       87
       -
       }

     

       88
       88
       -
       

     

       89
       89
       -
       impl jacquard_common::IntoStatic for BranchesError<'_> {

     

       90
       90
       -
           type Output = BranchesError<'static>;

     

       91
       91
       -
           fn into_static(self) -> Self::Output {

     

       92
       92
       -
               match self {

     

       93
       93
       -
                   BranchesError::RepoNotFound(v) => {

     

       94
       94
       -
                       BranchesError::RepoNotFound(v.into_static())

     

       95
       95
       -
                   }

     

       96
       96
       -
                   BranchesError::InvalidRequest(v) => {

     

       97
       97
       -
                       BranchesError::InvalidRequest(v.into_static())

     

       98
       98
       -
                   }

     

       99
       99
       -
                   BranchesError::Unknown(v) => BranchesError::Unknown(v.into_static()),

     

       100
       86
        
               }

     

       101
       87
        
           }

     

       102
       88
        
       }

+2 -18

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

···

       51
       51
        
           PartialEq,

     

       52
       52
        
           Eq,

     

       53
       53
        
           thiserror::Error,

     

       54
       54
       -
           miette::Diagnostic

     

       54
       54
       +
           miette::Diagnostic,

     

       55
       55
       +
           jacquard_derive::IntoStatic

     

       55
       56
        
       )]

     

       56
       57
        
       #[serde(tag = "error", content = "message")]

     

       57
       58
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       102
       103
        
                       Ok(())

     

       103
       104
        
                   }

     

       104
       105
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       105
       105
       -
               }

     

       106
       106
       -
           }

     

       107
       107
       -
       }

     

       108
       108
       -
       

     

       109
       109
       -
       impl jacquard_common::IntoStatic for CompareError<'_> {

     

       110
       110
       -
           type Output = CompareError<'static>;

     

       111
       111
       -
           fn into_static(self) -> Self::Output {

     

       112
       112
       -
               match self {

     

       113
       113
       -
                   CompareError::RepoNotFound(v) => CompareError::RepoNotFound(v.into_static()),

     

       114
       114
       -
                   CompareError::RevisionNotFound(v) => {

     

       115
       115
       -
                       CompareError::RevisionNotFound(v.into_static())

     

       116
       116
       -
                   }

     

       117
       117
       -
                   CompareError::InvalidRequest(v) => {

     

       118
       118
       -
                       CompareError::InvalidRequest(v.into_static())

     

       119
       119
       -
                   }

     

       120
       120
       -
                   CompareError::CompareError(v) => CompareError::CompareError(v.into_static()),

     

       121
       121
       -
                   CompareError::Unknown(v) => CompareError::Unknown(v.into_static()),

     

       122
       106
        
               }

     

       123
       107
        
           }

     

       124
       108
        
       }

+2 -13

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

···

       47
       47
        
           PartialEq,

     

       48
       48
        
           Eq,

     

       49
       49
        
           thiserror::Error,

     

       50
       50
       -
           miette::Diagnostic

     

       50
       50
       +
           miette::Diagnostic,

     

       51
       51
       +
           jacquard_derive::IntoStatic

     

       51
       52
        
       )]

     

       52
       53
        
       #[serde(tag = "error", content = "message")]

     

       53
       54
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       88
       89
        
                       Ok(())

     

       89
       90
        
                   }

     

       90
       91
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       91
       91
       -
               }

     

       92
       92
       -
           }

     

       93
       93
       -
       }

     

       94
       94
       -
       

     

       95
       95
       -
       impl jacquard_common::IntoStatic for DiffError<'_> {

     

       96
       96
       -
           type Output = DiffError<'static>;

     

       97
       97
       -
           fn into_static(self) -> Self::Output {

     

       98
       98
       -
               match self {

     

       99
       99
       -
                   DiffError::RepoNotFound(v) => DiffError::RepoNotFound(v.into_static()),

     

       100
       100
       -
                   DiffError::RefNotFound(v) => DiffError::RefNotFound(v.into_static()),

     

       101
       101
       -
                   DiffError::InvalidRequest(v) => DiffError::InvalidRequest(v.into_static()),

     

       102
       102
       -
                   DiffError::Unknown(v) => DiffError::Unknown(v.into_static()),

     

       103
       92
        
               }

     

       104
       93
        
           }

     

       105
       94
        
       }

+2 -18

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

···

       65
       65
        
           PartialEq,

     

       66
       66
        
           Eq,

     

       67
       67
        
           thiserror::Error,

     

       68
       68
       -
           miette::Diagnostic

     

       68
       68
       +
           miette::Diagnostic,

     

       69
       69
       +
           jacquard_derive::IntoStatic

     

       69
       70
        
       )]

     

       70
       71
        
       #[serde(tag = "error", content = "message")]

     

       71
       72
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       96
       97
        
                       Ok(())

     

       97
       98
        
                   }

     

       98
       99
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       99
       99
       -
               }

     

       100
       100
       -
           }

     

       101
       101
       -
       }

     

       102
       102
       -
       

     

       103
       103
       -
       impl jacquard_common::IntoStatic for GetDefaultBranchError<'_> {

     

       104
       104
       -
           type Output = GetDefaultBranchError<'static>;

     

       105
       105
       -
           fn into_static(self) -> Self::Output {

     

       106
       106
       -
               match self {

     

       107
       107
       -
                   GetDefaultBranchError::RepoNotFound(v) => {

     

       108
       108
       -
                       GetDefaultBranchError::RepoNotFound(v.into_static())

     

       109
       109
       -
                   }

     

       110
       110
       -
                   GetDefaultBranchError::InvalidRequest(v) => {

     

       111
       111
       -
                       GetDefaultBranchError::InvalidRequest(v.into_static())

     

       112
       112
       -
                   }

     

       113
       113
       -
                   GetDefaultBranchError::Unknown(v) => {

     

       114
       114
       -
                       GetDefaultBranchError::Unknown(v.into_static())

     

       115
       115
       -
                   }

     

       116
       100
        
               }

     

       117
       101
        
           }

     

       118
       102
        
       }

+2 -19

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

···

       94
       94
        
           PartialEq,

     

       95
       95
        
           Eq,

     

       96
       96
        
           thiserror::Error,

     

       97
       97
       -
           miette::Diagnostic

     

       97
       97
       +
           miette::Diagnostic,

     

       98
       98
       +
           jacquard_derive::IntoStatic

     

       98
       99
        
       )]

     

       99
       100
        
       #[serde(tag = "error", content = "message")]

     

       100
       101
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       135
       136
        
                       Ok(())

     

       136
       137
        
                   }

     

       137
       138
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       138
       138
       -
               }

     

       139
       139
       -
           }

     

       140
       140
       -
       }

     

       141
       141
       -
       

     

       142
       142
       -
       impl jacquard_common::IntoStatic for LanguagesError<'_> {

     

       143
       143
       -
           type Output = LanguagesError<'static>;

     

       144
       144
       -
           fn into_static(self) -> Self::Output {

     

       145
       145
       -
               match self {

     

       146
       146
       -
                   LanguagesError::RepoNotFound(v) => {

     

       147
       147
       -
                       LanguagesError::RepoNotFound(v.into_static())

     

       148
       148
       -
                   }

     

       149
       149
       -
                   LanguagesError::RefNotFound(v) => {

     

       150
       150
       -
                       LanguagesError::RefNotFound(v.into_static())

     

       151
       151
       -
                   }

     

       152
       152
       -
                   LanguagesError::InvalidRequest(v) => {

     

       153
       153
       -
                       LanguagesError::InvalidRequest(v.into_static())

     

       154
       154
       -
                   }

     

       155
       155
       -
                   LanguagesError::Unknown(v) => LanguagesError::Unknown(v.into_static()),

     

       156
       139
        
               }

     

       157
       140
        
           }

     

       158
       141
        
       }

+2 -14

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

···

       59
       59
        
           PartialEq,

     

       60
       60
        
           Eq,

     

       61
       61
        
           thiserror::Error,

     

       62
       62
       -
           miette::Diagnostic

     

       62
       62
       +
           miette::Diagnostic,

     

       63
       63
       +
           jacquard_derive::IntoStatic

     

       63
       64
        
       )]

     

       64
       65
        
       #[serde(tag = "error", content = "message")]

     

       65
       66
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       110
       111
        
                       Ok(())

     

       111
       112
        
                   }

     

       112
       113
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       113
       113
       -
               }

     

       114
       114
       -
           }

     

       115
       115
       -
       }

     

       116
       116
       -
       

     

       117
       117
       -
       impl jacquard_common::IntoStatic for LogError<'_> {

     

       118
       118
       -
           type Output = LogError<'static>;

     

       119
       119
       -
           fn into_static(self) -> Self::Output {

     

       120
       120
       -
               match self {

     

       121
       121
       -
                   LogError::RepoNotFound(v) => LogError::RepoNotFound(v.into_static()),

     

       122
       122
       -
                   LogError::RefNotFound(v) => LogError::RefNotFound(v.into_static()),

     

       123
       123
       -
                   LogError::PathNotFound(v) => LogError::PathNotFound(v.into_static()),

     

       124
       124
       -
                   LogError::InvalidRequest(v) => LogError::InvalidRequest(v.into_static()),

     

       125
       125
       -
                   LogError::Unknown(v) => LogError::Unknown(v.into_static()),

     

       126
       114
        
               }

     

       127
       115
        
           }

     

       128
       116
        
       }

+2 -12

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

···

       51
       51
        
           PartialEq,

     

       52
       52
        
           Eq,

     

       53
       53
        
           thiserror::Error,

     

       54
       54
       -
           miette::Diagnostic

     

       54
       54
       +
           miette::Diagnostic,

     

       55
       55
       +
           jacquard_derive::IntoStatic

     

       55
       56
        
       )]

     

       56
       57
        
       #[serde(tag = "error", content = "message")]

     

       57
       58
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       82
       83
        
                       Ok(())

     

       83
       84
        
                   }

     

       84
       85
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       85
       85
       -
               }

     

       86
       86
       -
           }

     

       87
       87
       -
       }

     

       88
       88
       -
       

     

       89
       89
       -
       impl jacquard_common::IntoStatic for TagsError<'_> {

     

       90
       90
       -
           type Output = TagsError<'static>;

     

       91
       91
       -
           fn into_static(self) -> Self::Output {

     

       92
       92
       -
               match self {

     

       93
       93
       -
                   TagsError::RepoNotFound(v) => TagsError::RepoNotFound(v.into_static()),

     

       94
       94
       -
                   TagsError::InvalidRequest(v) => TagsError::InvalidRequest(v.into_static()),

     

       95
       95
       -
                   TagsError::Unknown(v) => TagsError::Unknown(v.into_static()),

     

       96
       86
        
               }

     

       97
       87
        
           }

     

       98
       88
        
       }

+2 -14

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

···

       93
       93
        
           PartialEq,

     

       94
       94
        
           Eq,

     

       95
       95
        
           thiserror::Error,

     

       96
       96
       -
           miette::Diagnostic

     

       96
       96
       +
           miette::Diagnostic,

     

       97
       97
       +
           jacquard_derive::IntoStatic

     

       97
       98
        
       )]

     

       98
       99
        
       #[serde(tag = "error", content = "message")]

     

       99
       100
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       144
       145
        
                       Ok(())

     

       145
       146
        
                   }

     

       146
       147
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       147
       147
       -
               }

     

       148
       148
       -
           }

     

       149
       149
       -
       }

     

       150
       150
       -
       

     

       151
       151
       -
       impl jacquard_common::IntoStatic for TreeError<'_> {

     

       152
       152
       -
           type Output = TreeError<'static>;

     

       153
       153
       -
           fn into_static(self) -> Self::Output {

     

       154
       154
       -
               match self {

     

       155
       155
       -
                   TreeError::RepoNotFound(v) => TreeError::RepoNotFound(v.into_static()),

     

       156
       156
       -
                   TreeError::RefNotFound(v) => TreeError::RefNotFound(v.into_static()),

     

       157
       157
       -
                   TreeError::PathNotFound(v) => TreeError::PathNotFound(v.into_static()),

     

       158
       158
       -
                   TreeError::InvalidRequest(v) => TreeError::InvalidRequest(v.into_static()),

     

       159
       159
       -
                   TreeError::Unknown(v) => TreeError::Unknown(v.into_static()),

     

       160
       148
        
               }

     

       161
       149
        
           }

     

       162
       150
        
       }

+4 -4

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

···

       44
       44
        
       #[serde(rename_all = "camelCase")]

     

       45
       45
        
       pub struct ProfileDataView<'a> {

     

       46
       46
        
           #[serde(borrow)]

     

       47
       47
       -
           pub inner: ProfileDataViewRecordInner<'a>,

     

       47
       47
       +
           pub inner: ProfileDataViewInner<'a>,

     

       48
       48
        
       }

     

       49
       49
        
       

     

       50
       50
        
       #[jacquard_derive::open_union]

     
···

       59
       59
        
       )]

     

       60
       60
        
       #[serde(tag = "$type")]

     

       61
       61
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       62
       62
       -
       pub enum ProfileDataViewRecordInner<'a> {

     

       62
       62
       +
       pub enum ProfileDataViewInner<'a> {

     

       63
       63
        
           #[serde(rename = "sh.weaver.actor.defs#profileView")]

     

       64
       64
       -
           DefsProfileView(Box<crate::sh_weaver::actor::ProfileView<'a>>),

     

       64
       64
       +
           ProfileView(Box<crate::sh_weaver::actor::ProfileView<'a>>),

     

       65
       65
        
           #[serde(rename = "app.bsky.actor.defs#profileViewDetailed")]

     

       66
       66
       -
           DefsProfileViewDetailed(Box<crate::app_bsky::actor::ProfileViewDetailed<'a>>),

     

       66
       66
       +
           ProfileViewDetailed(Box<crate::app_bsky::actor::ProfileViewDetailed<'a>>),

     

       67
       67
        
       }

     

       68
       68
        
       

     

       69
       69
        
       #[jacquard_derive::lexicon]

+8 -2

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

···

       22
       22
        
       #[serde(rename_all = "camelCase")]

     

       23
       23
        
       pub struct DocRef<'a> {

     

       24
       24
        
           #[serde(borrow)]

     

       25
       25
       -
           pub value: DocRefRecordValue<'a>,

     

       25
       25
       +
           pub value: DocRefValue<'a>,

     

       26
       26
        
       }

     

       27
       27
        
       

     

       28
       28
        
       #[jacquard_derive::open_union]

     
···

       37
       37
        
       )]

     

       38
       38
        
       #[serde(tag = "$type")]

     

       39
       39
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       40
       40
       -
       pub enum DocRefRecordValue<'a> {}

     

       40
       40
       +
       pub enum DocRefValue<'a> {

     

       41
       41
       +
           #[serde(rename = "sh.weaver.edit.defs#notebookRef")]

     

       42
       42
       +
           NotebookRef(Box<crate::sh_weaver::edit::NotebookRef<'a>>),

     

       43
       43
       +
           #[serde(rename = "sh.weaver.edit.defs#entryRef")]

     

       44
       44
       +
           EntryRef(Box<crate::sh_weaver::edit::EntryRef<'a>>),

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       41
       47
        
       #[jacquard_derive::lexicon]

     

       42
       48
        
       #[derive(

     

       43
       49
        
           serde::Serialize,

+8 -2

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

···

       18
       18
        
       #[serde(rename_all = "camelCase")]

     

       19
       19
        
       pub struct ContainerId<'a> {

     

       20
       20
        
           #[serde(borrow)]

     

       21
       21
       -
           pub value: ContainerIdRecordValue<'a>,

     

       21
       21
       +
           pub value: ContainerIdValue<'a>,

     

       22
       22
        
       }

     

       23
       23
        
       

     

       24
       24
        
       #[jacquard_derive::open_union]

     
···

       33
       33
        
       )]

     

       34
       34
        
       #[serde(tag = "$type")]

     

       35
       35
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       36
       36
       -
       pub enum ContainerIdRecordValue<'a> {}

     

       36
       36
       +
       pub enum ContainerIdValue<'a> {

     

       37
       37
       +
           #[serde(rename = "sh.weaver.edit.cursor#normalContainerId")]

     

       38
       38
       +
           NormalContainerId(Box<crate::sh_weaver::edit::cursor::NormalContainerId<'a>>),

     

       39
       39
       +
           #[serde(rename = "sh.weaver.edit.cursor#rootContainerId")]

     

       40
       40
       +
           RootContainerId(Box<crate::sh_weaver::edit::cursor::RootContainerId<'a>>),

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       37
       43
        
       #[jacquard_derive::lexicon]

     

       38
       44
        
       #[derive(

     

       39
       45
        
           serde::Serialize,

+5 -5

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

···

       26
       26
        
           pub blurhash: std::option::Option<jacquard_common::CowStr<'a>>,

     

       27
       27
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
        
           #[serde(borrow)]

     

       29
       29
       -
           pub dimensions: std::option::Option<ImageRecordDimensions<'a>>,

     

       29
       29
       +
           pub dimensions: std::option::Option<ImageDimensions<'a>>,

     

       30
       30
        
           #[serde(borrow)]

     

       31
       31
        
           pub image: jacquard_common::types::blob::Blob<'a>,

     

       32
       32
        
       }

     
···

       43
       43
        
       )]

     

       44
       44
        
       #[serde(tag = "$type")]

     

       45
       45
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       46
       46
       -
       pub enum ImageRecordDimensions<'a> {

     

       46
       46
       +
       pub enum ImageDimensions<'a> {

     

       47
       47
        
           #[serde(rename = "app.bsky.embed.defs#aspectRatio")]

     

       48
       48
       -
           DefsAspectRatio(Box<crate::app_bsky::embed::AspectRatio<'a>>),

     

       48
       48
       +
           AspectRatio(Box<crate::app_bsky::embed::AspectRatio<'a>>),

     

       49
       49
        
           #[serde(rename = "sh.weaver.embed.defs#percentSize")]

     

       50
       50
       -
           DefsPercentSize(Box<crate::sh_weaver::embed::PercentSize<'a>>),

     

       50
       50
       +
           PercentSize(Box<crate::sh_weaver::embed::PercentSize<'a>>),

     

       51
       51
        
           #[serde(rename = "sh.weaver.embed.defs#pixelSize")]

     

       52
       52
       -
           DefsPixelSize(Box<crate::sh_weaver::embed::PixelSize<'a>>),

     

       52
       52
       +
           PixelSize(Box<crate::sh_weaver::embed::PixelSize<'a>>),

     

       53
       53
        
       }

     

       54
       54
        
       

     

       55
       55
        
       #[jacquard_derive::lexicon]

+8 -8

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

···

       18
       18
        
       #[serde(rename_all = "camelCase")]

     

       19
       19
        
       pub struct RecordWithMedia<'a> {

     

       20
       20
        
           #[serde(borrow)]

     

       21
       21
       -
           pub media: RecordWithMediaRecordMedia<'a>,

     

       21
       21
       +
           pub media: RecordWithMediaMedia<'a>,

     

       22
       22
        
           #[serde(borrow)]

     

       23
       23
       -
           pub record: RecordWithMediaRecordRecord<'a>,

     

       23
       23
       +
           pub record: RecordWithMediaRecord<'a>,

     

       24
       24
        
       }

     

       25
       25
        
       

     

       26
       26
        
       #[jacquard_derive::open_union]

     
···

       35
       35
        
       )]

     

       36
       36
        
       #[serde(tag = "$type")]

     

       37
       37
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       38
       38
       -
       pub enum RecordWithMediaRecordMedia<'a> {

     

       38
       38
       +
       pub enum RecordWithMediaMedia<'a> {

     

       39
       39
        
           #[serde(rename = "sh.weaver.embed.images")]

     

       40
       40
        
           Images(Box<crate::sh_weaver::embed::images::Images<'a>>),

     

       41
       41
        
           #[serde(rename = "sh.weaver.embed.external")]

     
···

       60
       60
        
       )]

     

       61
       61
        
       #[serde(tag = "$type")]

     

       62
       62
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       63
       63
       -
       pub enum RecordWithMediaRecordRecord<'a> {

     

       63
       63
       +
       pub enum RecordWithMediaRecord<'a> {

     

       64
       64
        
           #[serde(rename = "app.bsky.embed.record")]

     

       65
       65
        
           Record(Box<crate::app_bsky::embed::record::Record<'a>>),

     

       66
       66
        
           #[serde(rename = "sh.weaver.embed.records")]

     
···

       80
       80
        
       #[serde(rename_all = "camelCase")]

     

       81
       81
        
       pub struct View<'a> {

     

       82
       82
        
           #[serde(borrow)]

     

       83
       83
       -
           pub media: ViewRecordMedia<'a>,

     

       83
       83
       +
           pub media: ViewMedia<'a>,

     

       84
       84
        
           #[serde(borrow)]

     

       85
       85
       -
           pub record: ViewRecordRecord<'a>,

     

       85
       85
       +
           pub record: ViewRecord<'a>,

     

       86
       86
        
       }

     

       87
       87
        
       

     

       88
       88
        
       #[jacquard_derive::open_union]

     
···

       97
       97
        
       )]

     

       98
       98
        
       #[serde(tag = "$type")]

     

       99
       99
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       100
       100
       -
       pub enum ViewRecordMedia<'a> {

     

       100
       100
       +
       pub enum ViewMedia<'a> {

     

       101
       101
        
           #[serde(rename = "sh.weaver.embed.images")]

     

       102
       102
        
           Images(Box<crate::sh_weaver::embed::images::Images<'a>>),

     

       103
       103
        
           #[serde(rename = "sh.weaver.embed.external#view")]

     
···

       122
       122
        
       )]

     

       123
       123
        
       #[serde(tag = "$type")]

     

       124
       124
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       125
       125
       -
       pub enum ViewRecordRecord<'a> {

     

       125
       125
       +
       pub enum ViewRecord<'a> {

     

       126
       126
        
           #[serde(rename = "sh.weaver.embed.records#view")]

     

       127
       127
        
           RecordsView(Box<crate::sh_weaver::embed::records::View<'a>>),

     

       128
       128
        
           #[serde(rename = "app.bsky.embed.record#view")]

+29 -11

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

···

       34
       34
        
       #[serde(rename_all = "camelCase")]

     

       35
       35
        
       pub struct View<'a> {

     

       36
       36
        
           #[serde(borrow)]

     

       37
       37
       -
           pub record: ViewRecordRecord<'a>,

     

       37
       37
       +
           pub record: ViewUnionRecord<'a>,

     

       38
       38
        
       }

     

       39
       39
        
       

     

       40
       40
        
       #[jacquard_derive::open_union]

     
···

       49
       49
        
       )]

     

       50
       50
        
       #[serde(tag = "$type")]

     

       51
       51
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       52
       52
       -
       pub enum ViewRecordRecord<'a> {

     

       52
       52
       +
       pub enum ViewUnionRecord<'a> {

     

       53
       53
       +
           #[serde(rename = "sh.weaver.embed.records#viewRecord")]

     

       54
       54
       +
           ViewRecord(Box<crate::sh_weaver::embed::records::ViewRecord<'a>>),

     

       55
       55
       +
           #[serde(rename = "sh.weaver.embed.records#viewNotFound")]

     

       56
       56
       +
           ViewNotFound(Box<crate::sh_weaver::embed::records::ViewNotFound<'a>>),

     

       57
       57
       +
           #[serde(rename = "sh.weaver.embed.records#viewBlocked")]

     

       58
       58
       +
           ViewBlocked(Box<crate::sh_weaver::embed::records::ViewBlocked<'a>>),

     

       59
       59
       +
           #[serde(rename = "sh.weaver.embed.records#viewDetached")]

     

       60
       60
       +
           ViewDetached(Box<crate::sh_weaver::embed::records::ViewDetached<'a>>),

     

       53
       61
        
           #[serde(rename = "app.bsky.feed.defs#generatorView")]

     

       54
       54
       -
           DefsGeneratorView(Box<crate::app_bsky::feed::GeneratorView<'a>>),

     

       62
       62
       +
           GeneratorView(Box<crate::app_bsky::feed::GeneratorView<'a>>),

     

       55
       63
        
           #[serde(rename = "app.bsky.graph.defs#listView")]

     

       56
       56
       -
           DefsListView(Box<crate::app_bsky::graph::ListView<'a>>),

     

       64
       64
       +
           ListView(Box<crate::app_bsky::graph::ListView<'a>>),

     

       57
       65
        
           #[serde(rename = "app.bsky.labeler.defs#labelerView")]

     

       58
       58
       -
           DefsLabelerView(Box<crate::app_bsky::labeler::LabelerView<'a>>),

     

       66
       66
       +
           LabelerView(Box<crate::app_bsky::labeler::LabelerView<'a>>),

     

       59
       67
        
           #[serde(rename = "app.bsky.graph.defs#starterPackViewBasic")]

     

       60
       60
       -
           DefsStarterPackViewBasic(Box<crate::app_bsky::graph::StarterPackViewBasic<'a>>),

     

       68
       68
       +
           StarterPackViewBasic(Box<crate::app_bsky::graph::StarterPackViewBasic<'a>>),

     

       61
       69
        
       }

     

       62
       70
        
       

     

       63
       71
        
       #[jacquard_derive::lexicon]

     
···

       126
       134
        
       #[serde(rename_all = "camelCase")]

     

       127
       135
        
       pub struct ViewRecord<'a> {

     

       128
       136
        
           #[serde(borrow)]

     

       129
       129
       -
           pub author: ViewRecordRecordAuthor<'a>,

     

       137
       137
       +
           pub author: crate::app_bsky::actor::ProfileViewBasic<'a>,

     

       130
       138
        
           #[serde(borrow)]

     

       131
       139
        
           pub cid: jacquard_common::types::string::Cid<'a>,

     

       132
       140
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       133
       141
        
           #[serde(borrow)]

     

       134
       134
       -
           pub embeds: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       142
       142
       +
           pub embeds: std::option::Option<Vec<ViewRecordEmbedsItem<'a>>>,

     

       135
       143
        
           pub indexed_at: jacquard_common::types::string::Datetime,

     

       136
       144
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       137
       145
        
           #[serde(borrow)]

     
···

       163
       171
        
       )]

     

       164
       172
        
       #[serde(tag = "$type")]

     

       165
       173
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       166
       166
       -
       pub enum ViewRecordRecordAuthor<'a> {

     

       167
       167
       -
           #[serde(rename = "app.bsky.actor.defs#profileViewBasic")]

     

       168
       168
       -
           DefsProfileViewBasic(Box<crate::app_bsky::actor::ProfileViewBasic<'a>>),

     

       174
       174
       +
       pub enum ViewRecordEmbedsItem<'a> {

     

       175
       175
       +
           #[serde(rename = "app.bsky.embed.images#view")]

     

       176
       176
       +
           ImagesView(Box<crate::app_bsky::embed::images::View<'a>>),

     

       177
       177
       +
           #[serde(rename = "app.bsky.embed.video#view")]

     

       178
       178
       +
           VideoView(Box<crate::app_bsky::embed::video::View<'a>>),

     

       179
       179
       +
           #[serde(rename = "app.bsky.embed.external#view")]

     

       180
       180
       +
           ExternalView(Box<crate::app_bsky::embed::external::View<'a>>),

     

       181
       181
       +
           #[serde(rename = "app.bsky.embed.record#view")]

     

       182
       182
       +
           RecordView(Box<crate::app_bsky::embed::record::View<'a>>),

     

       183
       183
       +
           #[serde(rename = "app.bsky.embed.recordWithMedia#view")]

     

       184
       184
       +
           RecordWithMediaView(Box<crate::app_bsky::embed::record_with_media::View<'a>>),

     

       185
       185
       +
           #[serde(rename = "sh.weaver.embed.records#view")]

     

       186
       186
       +
           View(Box<crate::sh_weaver::embed::records::View<'a>>),

     

       169
       187
        
       }

+4 -4

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

···

       22
       22
        
           pub index: std::option::Option<i64>,

     

       23
       23
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       24
       24
        
           #[serde(borrow)]

     

       25
       25
       -
           pub profile: std::option::Option<AuthorListItemRecordProfile<'a>>,

     

       25
       25
       +
           pub profile: std::option::Option<AuthorListItemProfile<'a>>,

     

       26
       26
        
       }

     

       27
       27
        
       

     

       28
       28
        
       #[jacquard_derive::open_union]

     
···

       37
       37
        
       )]

     

       38
       38
        
       #[serde(tag = "$type")]

     

       39
       39
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       40
       40
       -
       pub enum AuthorListItemRecordProfile<'a> {

     

       40
       40
       +
       pub enum AuthorListItemProfile<'a> {

     

       41
       41
        
           #[serde(rename = "app.bsky.actor.defs#profileViewBasic")]

     

       42
       42
       -
           DefsProfileViewBasic(Box<crate::app_bsky::actor::ProfileViewBasic<'a>>),

     

       42
       42
       +
           ProfileViewBasic(Box<crate::app_bsky::actor::ProfileViewBasic<'a>>),

     

       43
       43
        
           #[serde(rename = "sh.weaver.actor.defs#profileView")]

     

       44
       44
       -
           DefsProfileView(Box<crate::sh_weaver::actor::ProfileView<'a>>),

     

       44
       44
       +
           ProfileView(Box<crate::sh_weaver::actor::ProfileView<'a>>),

     

       45
       45
        
       }

     

       46
       46
        
       

     

       47
       47
        
       ///Authors of a Weaver notebook.

+18 -1

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

···

       13
       13
        
       pub mod search_profiles;

     

       14
       14
        
       pub mod search_tags;

     

       15
       15
        
       

     

       16
       16
       +
       #[jacquard_derive::open_union]

     

       17
       17
       +
       #[derive(

     

       18
       18
       +
           serde::Serialize,

     

       19
       19
       +
           serde::Deserialize,

     

       20
       20
       +
           Debug,

     

       21
       21
       +
           Clone,

     

       22
       22
       +
           PartialEq,

     

       23
       23
       +
           Eq,

     

       24
       24
       +
           jacquard_derive::IntoStatic

     

       25
       25
       +
       )]

     

       26
       26
       +
       #[serde(tag = "$type")]

     

       27
       27
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       28
       28
       +
       pub enum PreferencesItem<'a> {

     

       29
       29
       +
           #[serde(rename = "social.clippr.actor.defs#publishingScopesPref")]

     

       30
       30
       +
           PublishingScopesPref(Box<crate::social_clippr::actor::PublishingScopesPref<'a>>),

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       16
       33
        
       ///An array of refs to various preferences.

     

       17
       17
       -
       pub type Preferences<'a> = Vec<jacquard_common::types::value::Data<'a>>;

     

       34
       34
       +
       pub type Preferences<'a> = Vec<PreferencesItem<'a>>;

     

       18
       35
        
       ///A view of an actor's profile.

     

       19
       36
        
       #[jacquard_derive::lexicon]

     

       20
       37
        
       #[derive(

+2 -19

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

···

       26
       26
        
           ///Self-label values for this post. Effectively content warnings.

     

       27
       27
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
        
           #[serde(borrow)]

     

       29
       29
       -
           pub labels: std::option::Option<GalleryRecordLabels<'a>>,

     

       29
       29
       +
           pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,

     

       30
       30
        
           #[serde(borrow)]

     

       31
       31
        
           pub title: jacquard_common::CowStr<'a>,

     

       32
       32
       -
       }

     

       33
       33
       -
       

     

       34
       34
       -
       #[jacquard_derive::open_union]

     

       35
       35
       -
       #[derive(

     

       36
       36
       -
           serde::Serialize,

     

       37
       37
       -
           serde::Deserialize,

     

       38
       38
       -
           Debug,

     

       39
       39
       -
           Clone,

     

       40
       40
       -
           PartialEq,

     

       41
       41
       -
           Eq,

     

       42
       42
       -
           jacquard_derive::IntoStatic

     

       43
       43
       -
       )]

     

       44
       44
       -
       #[serde(tag = "$type")]

     

       45
       45
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       46
       46
       -
       pub enum GalleryRecordLabels<'a> {

     

       47
       47
       -
           #[serde(rename = "com.atproto.label.defs#selfLabels")]

     

       48
       48
       -
           DefsSelfLabels(Box<crate::com_atproto::label::SelfLabels<'a>>),

     

       49
       32
        
       }

     

       50
       33
        
       

     

       51
       34
        
       impl jacquard_common::types::collection::Collection for Gallery<'_> {

     
···

       71
       54
        
           pub indexed_at: jacquard_common::types::string::Datetime,

     

       72
       55
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       73
       56
        
           #[serde(borrow)]

     

       74
       74
       -
           pub items: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       57
       57
       +
           pub items: std::option::Option<Vec<crate::social_grain::photo::PhotoView<'a>>>,

     

       75
       58
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       76
       59
        
           #[serde(borrow)]

     

       77
       60
        
           pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,

+22 -1

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

···

       53
       53
        
       #[serde(rename_all = "camelCase")]

     

       54
       54
        
       pub struct Facet<'a> {

     

       55
       55
        
           #[serde(borrow)]

     

       56
       56
       -
           pub features: Vec<jacquard_common::types::value::Data<'a>>,

     

       56
       56
       +
           pub features: Vec<FacetFeaturesItem<'a>>,

     

       57
       57
        
           #[serde(borrow)]

     

       58
       58
        
           pub index: crate::social_psky::richtext::facet::ByteSlice<'a>,

     

       59
       59
       +
       }

     

       60
       60
       +
       

     

       61
       61
       +
       #[jacquard_derive::open_union]

     

       62
       62
       +
       #[derive(

     

       63
       63
       +
           serde::Serialize,

     

       64
       64
       +
           serde::Deserialize,

     

       65
       65
       +
           Debug,

     

       66
       66
       +
           Clone,

     

       67
       67
       +
           PartialEq,

     

       68
       68
       +
           Eq,

     

       69
       69
       +
           jacquard_derive::IntoStatic

     

       70
       70
       +
       )]

     

       71
       71
       +
       #[serde(tag = "$type")]

     

       72
       72
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       73
       73
       +
       pub enum FacetFeaturesItem<'a> {

     

       74
       74
       +
           #[serde(rename = "social.psky.richtext.facet#mention")]

     

       75
       75
       +
           Mention(Box<crate::social_psky::richtext::facet::Mention<'a>>),

     

       76
       76
       +
           #[serde(rename = "social.psky.richtext.facet#link")]

     

       77
       77
       +
           Link(Box<crate::social_psky::richtext::facet::Link<'a>>),

     

       78
       78
       +
           #[serde(rename = "social.psky.richtext.facet#room")]

     

       79
       79
       +
           Room(Box<crate::social_psky::richtext::facet::Room<'a>>),

     

       59
       80
        
       }

     

       60
       81
        
       

     

       61
       82
        
       ///Facet feature for mention of another account. The text is usually a handle, including a '@' prefix, but the facet reference is a DID.

+2 -15

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

···

       73
       73
        
           PartialEq,

     

       74
       74
        
           Eq,

     

       75
       75
        
           thiserror::Error,

     

       76
       76
       -
           miette::Diagnostic

     

       76
       76
       +
           miette::Diagnostic,

     

       77
       77
       +
           jacquard_derive::IntoStatic

     

       77
       78
        
       )]

     

       78
       79
        
       #[serde(tag = "error", content = "message")]

     

       79
       80
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       93
       94
        
                       Ok(())

     

       94
       95
        
                   }

     

       95
       96
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       96
       96
       -
               }

     

       97
       97
       -
           }

     

       98
       98
       -
       }

     

       99
       99
       -
       

     

       100
       100
       -
       impl jacquard_common::IntoStatic for CreateTemplateError<'_> {

     

       101
       101
       -
           type Output = CreateTemplateError<'static>;

     

       102
       102
       -
           fn into_static(self) -> Self::Output {

     

       103
       103
       -
               match self {

     

       104
       104
       -
                   CreateTemplateError::DuplicateTemplateName(v) => {

     

       105
       105
       -
                       CreateTemplateError::DuplicateTemplateName(v.into_static())

     

       106
       106
       -
                   }

     

       107
       107
       -
                   CreateTemplateError::Unknown(v) => {

     

       108
       108
       -
                       CreateTemplateError::Unknown(v.into_static())

     

       109
       109
       -
                   }

     

       110
       97
        
               }

     

       111
       98
        
           }

     

       112
       99
        
       }

+2 -15

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

···

       82
       82
        
           PartialEq,

     

       83
       83
        
           Eq,

     

       84
       84
        
           thiserror::Error,

     

       85
       85
       -
           miette::Diagnostic

     

       85
       85
       +
           miette::Diagnostic,

     

       86
       86
       +
           jacquard_derive::IntoStatic

     

       86
       87
        
       )]

     

       87
       88
        
       #[serde(tag = "error", content = "message")]

     

       88
       89
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       102
       103
        
                       Ok(())

     

       103
       104
        
                   }

     

       104
       105
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       105
       105
       -
               }

     

       106
       106
       -
           }

     

       107
       107
       -
       }

     

       108
       108
       -
       

     

       109
       109
       -
       impl jacquard_common::IntoStatic for UpdateTemplateError<'_> {

     

       110
       110
       -
           type Output = UpdateTemplateError<'static>;

     

       111
       111
       -
           fn into_static(self) -> Self::Output {

     

       112
       112
       -
               match self {

     

       113
       113
       -
                   UpdateTemplateError::DuplicateTemplateName(v) => {

     

       114
       114
       -
                       UpdateTemplateError::DuplicateTemplateName(v.into_static())

     

       115
       115
       -
                   }

     

       116
       116
       -
                   UpdateTemplateError::Unknown(v) => {

     

       117
       117
       -
                       UpdateTemplateError::Unknown(v.into_static())

     

       118
       118
       -
                   }

     

       119
       106
        
               }

     

       120
       107
        
           }

     

       121
       108
        
       }

+24 -2

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

···

       73
       73
        
           #[serde(borrow)]

     

       74
       74
        
           pub created_by: jacquard_common::CowStr<'a>,

     

       75
       75
        
           #[serde(borrow)]

     

       76
       76
       -
           pub details: EventRecordDetails<'a>,

     

       76
       76
       +
           pub details: EventDetails<'a>,

     

       77
       77
        
       }

     

       78
       78
        
       

     

       79
       79
        
       #[jacquard_derive::open_union]

     
···

       88
       88
        
       )]

     

       89
       89
        
       #[serde(tag = "$type")]

     

       90
       90
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       91
       91
       -
       pub enum EventRecordDetails<'a> {}

     

       91
       91
       +
       pub enum EventDetails<'a> {

     

       92
       92
       +
           #[serde(rename = "tools.ozone.hosting.getAccountHistory#accountCreated")]

     

       93
       93
       +
           AccountCreated(

     

       94
       94
       +
               Box<crate::tools_ozone::hosting::get_account_history::AccountCreated<'a>>,

     

       95
       95
       +
           ),

     

       96
       96
       +
           #[serde(rename = "tools.ozone.hosting.getAccountHistory#emailUpdated")]

     

       97
       97
       +
           EmailUpdated(

     

       98
       98
       +
               Box<crate::tools_ozone::hosting::get_account_history::EmailUpdated<'a>>,

     

       99
       99
       +
           ),

     

       100
       100
       +
           #[serde(rename = "tools.ozone.hosting.getAccountHistory#emailConfirmed")]

     

       101
       101
       +
           EmailConfirmed(

     

       102
       102
       +
               Box<crate::tools_ozone::hosting::get_account_history::EmailConfirmed<'a>>,

     

       103
       103
       +
           ),

     

       104
       104
       +
           #[serde(rename = "tools.ozone.hosting.getAccountHistory#passwordUpdated")]

     

       105
       105
       +
           PasswordUpdated(

     

       106
       106
       +
               Box<crate::tools_ozone::hosting::get_account_history::PasswordUpdated<'a>>,

     

       107
       107
       +
           ),

     

       108
       108
       +
           #[serde(rename = "tools.ozone.hosting.getAccountHistory#handleUpdated")]

     

       109
       109
       +
           HandleUpdated(

     

       110
       110
       +
               Box<crate::tools_ozone::hosting::get_account_history::HandleUpdated<'a>>,

     

       111
       111
       +
           ),

     

       112
       112
       +
       }

     

       113
       113
       +
       

     

       92
       114
        
       #[jacquard_derive::lexicon]

     

       93
       115
        
       #[derive(

     

       94
       116
        
           serde::Serialize,

+173 -32

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

···

       178
       178
        
           pub created_at: jacquard_common::types::string::Datetime,

     

       179
       179
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       180
       180
        
           #[serde(borrow)]

     

       181
       181
       -
           pub details: std::option::Option<BlobViewRecordDetails<'a>>,

     

       181
       181
       +
           pub details: std::option::Option<BlobViewDetails<'a>>,

     

       182
       182
        
           #[serde(borrow)]

     

       183
       183
        
           pub mime_type: jacquard_common::CowStr<'a>,

     

       184
       184
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     
···

       199
       199
        
       )]

     

       200
       200
        
       #[serde(tag = "$type")]

     

       201
       201
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       202
       202
       -
       pub enum BlobViewRecordDetails<'a> {}

     

       202
       202
       +
       pub enum BlobViewDetails<'a> {

     

       203
       203
       +
           #[serde(rename = "tools.ozone.moderation.defs#imageDetails")]

     

       204
       204
       +
           ImageDetails(Box<crate::tools_ozone::moderation::ImageDetails<'a>>),

     

       205
       205
       +
           #[serde(rename = "tools.ozone.moderation.defs#videoDetails")]

     

       206
       206
       +
           VideoDetails(Box<crate::tools_ozone::moderation::VideoDetails<'a>>),

     

       207
       207
       +
       }

     

       208
       208
       +
       

     

       203
       209
        
       ///Logs cancellation of a scheduled takedown action for an account.

     

       204
       210
        
       #[jacquard_derive::lexicon]

     

       205
       211
        
       #[derive(

     
···

       619
       625
        
           #[serde(borrow)]

     

       620
       626
        
           pub creator_handle: std::option::Option<jacquard_common::CowStr<'a>>,

     

       621
       627
        
           #[serde(borrow)]

     

       622
       622
       -
           pub event: ModEventViewRecordEvent<'a>,

     

       628
       628
       +
           pub event: ModEventViewEvent<'a>,

     

       623
       629
        
           pub id: i64,

     

       624
       630
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       625
       631
        
           #[serde(borrow)]

     

       626
       632
        
           pub mod_tool: std::option::Option<crate::tools_ozone::moderation::ModTool<'a>>,

     

       627
       633
        
           #[serde(borrow)]

     

       628
       628
       -
           pub subject: ModEventViewRecordSubject<'a>,

     

       634
       634
       +
           pub subject: ModEventViewSubject<'a>,

     

       629
       635
        
           #[serde(borrow)]

     

       630
       636
        
           pub subject_blob_cids: Vec<jacquard_common::CowStr<'a>>,

     

       631
       637
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     
···

       645
       651
        
       )]

     

       646
       652
        
       #[serde(tag = "$type")]

     

       647
       653
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       648
       648
       -
       pub enum ModEventViewRecordEvent<'a> {}

     

       654
       654
       +
       pub enum ModEventViewEvent<'a> {

     

       655
       655
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventTakedown")]

     

       656
       656
       +
           ModEventTakedown(Box<crate::tools_ozone::moderation::ModEventTakedown<'a>>),

     

       657
       657
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventReverseTakedown")]

     

       658
       658
       +
           ModEventReverseTakedown(

     

       659
       659
       +
               Box<crate::tools_ozone::moderation::ModEventReverseTakedown<'a>>,

     

       660
       660
       +
           ),

     

       661
       661
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventComment")]

     

       662
       662
       +
           ModEventComment(Box<crate::tools_ozone::moderation::ModEventComment<'a>>),

     

       663
       663
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventReport")]

     

       664
       664
       +
           ModEventReport(Box<crate::tools_ozone::moderation::ModEventReport<'a>>),

     

       665
       665
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventLabel")]

     

       666
       666
       +
           ModEventLabel(Box<crate::tools_ozone::moderation::ModEventLabel<'a>>),

     

       667
       667
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventAcknowledge")]

     

       668
       668
       +
           ModEventAcknowledge(Box<crate::tools_ozone::moderation::ModEventAcknowledge<'a>>),

     

       669
       669
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventEscalate")]

     

       670
       670
       +
           ModEventEscalate(Box<crate::tools_ozone::moderation::ModEventEscalate<'a>>),

     

       671
       671
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventMute")]

     

       672
       672
       +
           ModEventMute(Box<crate::tools_ozone::moderation::ModEventMute<'a>>),

     

       673
       673
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventUnmute")]

     

       674
       674
       +
           ModEventUnmute(Box<crate::tools_ozone::moderation::ModEventUnmute<'a>>),

     

       675
       675
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventMuteReporter")]

     

       676
       676
       +
           ModEventMuteReporter(Box<crate::tools_ozone::moderation::ModEventMuteReporter<'a>>),

     

       677
       677
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventUnmuteReporter")]

     

       678
       678
       +
           ModEventUnmuteReporter(

     

       679
       679
       +
               Box<crate::tools_ozone::moderation::ModEventUnmuteReporter<'a>>,

     

       680
       680
       +
           ),

     

       681
       681
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventEmail")]

     

       682
       682
       +
           ModEventEmail(Box<crate::tools_ozone::moderation::ModEventEmail<'a>>),

     

       683
       683
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventResolveAppeal")]

     

       684
       684
       +
           ModEventResolveAppeal(

     

       685
       685
       +
               Box<crate::tools_ozone::moderation::ModEventResolveAppeal<'a>>,

     

       686
       686
       +
           ),

     

       687
       687
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventDivert")]

     

       688
       688
       +
           ModEventDivert(Box<crate::tools_ozone::moderation::ModEventDivert<'a>>),

     

       689
       689
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventTag")]

     

       690
       690
       +
           ModEventTag(Box<crate::tools_ozone::moderation::ModEventTag<'a>>),

     

       691
       691
       +
           #[serde(rename = "tools.ozone.moderation.defs#accountEvent")]

     

       692
       692
       +
           AccountEvent(Box<crate::tools_ozone::moderation::AccountEvent<'a>>),

     

       693
       693
       +
           #[serde(rename = "tools.ozone.moderation.defs#identityEvent")]

     

       694
       694
       +
           IdentityEvent(Box<crate::tools_ozone::moderation::IdentityEvent<'a>>),

     

       695
       695
       +
           #[serde(rename = "tools.ozone.moderation.defs#recordEvent")]

     

       696
       696
       +
           RecordEvent(Box<crate::tools_ozone::moderation::RecordEvent<'a>>),

     

       697
       697
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventPriorityScore")]

     

       698
       698
       +
           ModEventPriorityScore(

     

       699
       699
       +
               Box<crate::tools_ozone::moderation::ModEventPriorityScore<'a>>,

     

       700
       700
       +
           ),

     

       701
       701
       +
           #[serde(rename = "tools.ozone.moderation.defs#ageAssuranceEvent")]

     

       702
       702
       +
           AgeAssuranceEvent(Box<crate::tools_ozone::moderation::AgeAssuranceEvent<'a>>),

     

       703
       703
       +
           #[serde(rename = "tools.ozone.moderation.defs#ageAssuranceOverrideEvent")]

     

       704
       704
       +
           AgeAssuranceOverrideEvent(

     

       705
       705
       +
               Box<crate::tools_ozone::moderation::AgeAssuranceOverrideEvent<'a>>,

     

       706
       706
       +
           ),

     

       707
       707
       +
           #[serde(rename = "tools.ozone.moderation.defs#revokeAccountCredentialsEvent")]

     

       708
       708
       +
           RevokeAccountCredentialsEvent(

     

       709
       709
       +
               Box<crate::tools_ozone::moderation::RevokeAccountCredentialsEvent<'a>>,

     

       710
       710
       +
           ),

     

       711
       711
       +
           #[serde(rename = "tools.ozone.moderation.defs#scheduleTakedownEvent")]

     

       712
       712
       +
           ScheduleTakedownEvent(

     

       713
       713
       +
               Box<crate::tools_ozone::moderation::ScheduleTakedownEvent<'a>>,

     

       714
       714
       +
           ),

     

       715
       715
       +
           #[serde(rename = "tools.ozone.moderation.defs#cancelScheduledTakedownEvent")]

     

       716
       716
       +
           CancelScheduledTakedownEvent(

     

       717
       717
       +
               Box<crate::tools_ozone::moderation::CancelScheduledTakedownEvent<'a>>,

     

       718
       718
       +
           ),

     

       719
       719
       +
       }

     

       720
       720
       +
       

     

       649
       721
        
       #[jacquard_derive::open_union]

     

       650
       722
        
       #[derive(

     

       651
       723
        
           serde::Serialize,

     
···

       658
       730
        
       )]

     

       659
       731
        
       #[serde(tag = "$type")]

     

       660
       732
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       661
       661
       -
       pub enum ModEventViewRecordSubject<'a> {

     

       733
       733
       +
       pub enum ModEventViewSubject<'a> {

     

       662
       734
        
           #[serde(rename = "com.atproto.admin.defs#repoRef")]

     

       663
       663
       -
           DefsRepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       735
       735
       +
           RepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       664
       736
        
           #[serde(rename = "com.atproto.repo.strongRef")]

     

       665
       737
        
           StrongRef(Box<crate::com_atproto::repo::strong_ref::StrongRef<'a>>),

     

       666
       738
        
           #[serde(rename = "chat.bsky.convo.defs#messageRef")]

     

       667
       667
       -
           DefsMessageRef(Box<crate::chat_bsky::convo::MessageRef<'a>>),

     

       739
       739
       +
           MessageRef(Box<crate::chat_bsky::convo::MessageRef<'a>>),

     

       668
       740
        
       }

     

       669
       741
        
       

     

       670
       742
        
       #[jacquard_derive::lexicon]

     
···

       683
       755
        
           #[serde(borrow)]

     

       684
       756
        
           pub created_by: jacquard_common::types::string::Did<'a>,

     

       685
       757
        
           #[serde(borrow)]

     

       686
       686
       -
           pub event: ModEventViewDetailRecordEvent<'a>,

     

       758
       758
       +
           pub event: ModEventViewDetailEvent<'a>,

     

       687
       759
        
           pub id: i64,

     

       688
       760
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       689
       761
        
           #[serde(borrow)]

     

       690
       762
        
           pub mod_tool: std::option::Option<crate::tools_ozone::moderation::ModTool<'a>>,

     

       691
       763
        
           #[serde(borrow)]

     

       692
       692
       -
           pub subject: ModEventViewDetailRecordSubject<'a>,

     

       764
       764
       +
           pub subject: ModEventViewDetailSubject<'a>,

     

       693
       765
        
           #[serde(borrow)]

     

       694
       766
        
           pub subject_blobs: Vec<crate::tools_ozone::moderation::BlobView<'a>>,

     

       695
       767
        
       }

     
···

       706
       778
        
       )]

     

       707
       779
        
       #[serde(tag = "$type")]

     

       708
       780
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       709
       709
       -
       pub enum ModEventViewDetailRecordEvent<'a> {}

     

       781
       781
       +
       pub enum ModEventViewDetailEvent<'a> {

     

       782
       782
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventTakedown")]

     

       783
       783
       +
           ModEventTakedown(Box<crate::tools_ozone::moderation::ModEventTakedown<'a>>),

     

       784
       784
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventReverseTakedown")]

     

       785
       785
       +
           ModEventReverseTakedown(

     

       786
       786
       +
               Box<crate::tools_ozone::moderation::ModEventReverseTakedown<'a>>,

     

       787
       787
       +
           ),

     

       788
       788
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventComment")]

     

       789
       789
       +
           ModEventComment(Box<crate::tools_ozone::moderation::ModEventComment<'a>>),

     

       790
       790
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventReport")]

     

       791
       791
       +
           ModEventReport(Box<crate::tools_ozone::moderation::ModEventReport<'a>>),

     

       792
       792
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventLabel")]

     

       793
       793
       +
           ModEventLabel(Box<crate::tools_ozone::moderation::ModEventLabel<'a>>),

     

       794
       794
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventAcknowledge")]

     

       795
       795
       +
           ModEventAcknowledge(Box<crate::tools_ozone::moderation::ModEventAcknowledge<'a>>),

     

       796
       796
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventEscalate")]

     

       797
       797
       +
           ModEventEscalate(Box<crate::tools_ozone::moderation::ModEventEscalate<'a>>),

     

       798
       798
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventMute")]

     

       799
       799
       +
           ModEventMute(Box<crate::tools_ozone::moderation::ModEventMute<'a>>),

     

       800
       800
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventUnmute")]

     

       801
       801
       +
           ModEventUnmute(Box<crate::tools_ozone::moderation::ModEventUnmute<'a>>),

     

       802
       802
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventMuteReporter")]

     

       803
       803
       +
           ModEventMuteReporter(Box<crate::tools_ozone::moderation::ModEventMuteReporter<'a>>),

     

       804
       804
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventUnmuteReporter")]

     

       805
       805
       +
           ModEventUnmuteReporter(

     

       806
       806
       +
               Box<crate::tools_ozone::moderation::ModEventUnmuteReporter<'a>>,

     

       807
       807
       +
           ),

     

       808
       808
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventEmail")]

     

       809
       809
       +
           ModEventEmail(Box<crate::tools_ozone::moderation::ModEventEmail<'a>>),

     

       810
       810
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventResolveAppeal")]

     

       811
       811
       +
           ModEventResolveAppeal(

     

       812
       812
       +
               Box<crate::tools_ozone::moderation::ModEventResolveAppeal<'a>>,

     

       813
       813
       +
           ),

     

       814
       814
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventDivert")]

     

       815
       815
       +
           ModEventDivert(Box<crate::tools_ozone::moderation::ModEventDivert<'a>>),

     

       816
       816
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventTag")]

     

       817
       817
       +
           ModEventTag(Box<crate::tools_ozone::moderation::ModEventTag<'a>>),

     

       818
       818
       +
           #[serde(rename = "tools.ozone.moderation.defs#accountEvent")]

     

       819
       819
       +
           AccountEvent(Box<crate::tools_ozone::moderation::AccountEvent<'a>>),

     

       820
       820
       +
           #[serde(rename = "tools.ozone.moderation.defs#identityEvent")]

     

       821
       821
       +
           IdentityEvent(Box<crate::tools_ozone::moderation::IdentityEvent<'a>>),

     

       822
       822
       +
           #[serde(rename = "tools.ozone.moderation.defs#recordEvent")]

     

       823
       823
       +
           RecordEvent(Box<crate::tools_ozone::moderation::RecordEvent<'a>>),

     

       824
       824
       +
           #[serde(rename = "tools.ozone.moderation.defs#modEventPriorityScore")]

     

       825
       825
       +
           ModEventPriorityScore(

     

       826
       826
       +
               Box<crate::tools_ozone::moderation::ModEventPriorityScore<'a>>,

     

       827
       827
       +
           ),

     

       828
       828
       +
           #[serde(rename = "tools.ozone.moderation.defs#ageAssuranceEvent")]

     

       829
       829
       +
           AgeAssuranceEvent(Box<crate::tools_ozone::moderation::AgeAssuranceEvent<'a>>),

     

       830
       830
       +
           #[serde(rename = "tools.ozone.moderation.defs#ageAssuranceOverrideEvent")]

     

       831
       831
       +
           AgeAssuranceOverrideEvent(

     

       832
       832
       +
               Box<crate::tools_ozone::moderation::AgeAssuranceOverrideEvent<'a>>,

     

       833
       833
       +
           ),

     

       834
       834
       +
           #[serde(rename = "tools.ozone.moderation.defs#revokeAccountCredentialsEvent")]

     

       835
       835
       +
           RevokeAccountCredentialsEvent(

     

       836
       836
       +
               Box<crate::tools_ozone::moderation::RevokeAccountCredentialsEvent<'a>>,

     

       837
       837
       +
           ),

     

       838
       838
       +
           #[serde(rename = "tools.ozone.moderation.defs#scheduleTakedownEvent")]

     

       839
       839
       +
           ScheduleTakedownEvent(

     

       840
       840
       +
               Box<crate::tools_ozone::moderation::ScheduleTakedownEvent<'a>>,

     

       841
       841
       +
           ),

     

       842
       842
       +
           #[serde(rename = "tools.ozone.moderation.defs#cancelScheduledTakedownEvent")]

     

       843
       843
       +
           CancelScheduledTakedownEvent(

     

       844
       844
       +
               Box<crate::tools_ozone::moderation::CancelScheduledTakedownEvent<'a>>,

     

       845
       845
       +
           ),

     

       846
       846
       +
       }

     

       847
       847
       +
       

     

       710
       848
        
       #[jacquard_derive::open_union]

     

       711
       849
        
       #[derive(

     

       712
       850
        
           serde::Serialize,

     
···

       719
       857
        
       )]

     

       720
       858
        
       #[serde(tag = "$type")]

     

       721
       859
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       722
       722
       -
       pub enum ModEventViewDetailRecordSubject<'a> {}

     

       860
       860
       +
       pub enum ModEventViewDetailSubject<'a> {

     

       861
       861
       +
           #[serde(rename = "tools.ozone.moderation.defs#repoView")]

     

       862
       862
       +
           RepoView(Box<crate::tools_ozone::moderation::RepoView<'a>>),

     

       863
       863
       +
           #[serde(rename = "tools.ozone.moderation.defs#repoViewNotFound")]

     

       864
       864
       +
           RepoViewNotFound(Box<crate::tools_ozone::moderation::RepoViewNotFound<'a>>),

     

       865
       865
       +
           #[serde(rename = "tools.ozone.moderation.defs#recordView")]

     

       866
       866
       +
           RecordView(Box<crate::tools_ozone::moderation::RecordView<'a>>),

     

       867
       867
       +
           #[serde(rename = "tools.ozone.moderation.defs#recordViewNotFound")]

     

       868
       868
       +
           RecordViewNotFound(Box<crate::tools_ozone::moderation::RecordViewNotFound<'a>>),

     

       869
       869
       +
       }

     

       870
       870
       +
       

     

       723
       871
        
       ///Moderation tool information for tracing the source of the action

     

       724
       872
        
       #[jacquard_derive::lexicon]

     

       725
       873
        
       #[derive(

     
···

       1375
       1523
        
           pub created_at: jacquard_common::types::string::Datetime,

     

       1376
       1524
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       1377
       1525
        
           #[serde(borrow)]

     

       1378
       1378
       -
           pub hosting: std::option::Option<SubjectStatusViewRecordHosting<'a>>,

     

       1526
       1526
       +
           pub hosting: std::option::Option<SubjectStatusViewHosting<'a>>,

     

       1379
       1527
        
           pub id: i64,

     

       1380
       1528
        
           ///Timestamp referencing when the author of the subject appealed a moderation action

     

       1381
       1529
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     
···

       1405
       1553
        
           #[serde(borrow)]

     

       1406
       1554
        
           pub review_state: crate::tools_ozone::moderation::SubjectReviewState<'a>,

     

       1407
       1555
        
           #[serde(borrow)]

     

       1408
       1408
       -
           pub subject: SubjectStatusViewRecordSubject<'a>,

     

       1556
       1556
       +
           pub subject: SubjectStatusViewSubject<'a>,

     

       1409
       1557
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       1410
       1558
        
           #[serde(borrow)]

     

       1411
       1559
        
           pub subject_blob_cids: std::option::Option<

     
···

       1437
       1585
        
       )]

     

       1438
       1586
        
       #[serde(tag = "$type")]

     

       1439
       1587
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       1440
       1440
       -
       pub enum SubjectStatusViewRecordHosting<'a> {}

     

       1588
       1588
       +
       pub enum SubjectStatusViewHosting<'a> {

     

       1589
       1589
       +
           #[serde(rename = "tools.ozone.moderation.defs#accountHosting")]

     

       1590
       1590
       +
           AccountHosting(Box<crate::tools_ozone::moderation::AccountHosting<'a>>),

     

       1591
       1591
       +
           #[serde(rename = "tools.ozone.moderation.defs#recordHosting")]

     

       1592
       1592
       +
           RecordHosting(Box<crate::tools_ozone::moderation::RecordHosting<'a>>),

     

       1593
       1593
       +
       }

     

       1594
       1594
       +
       

     

       1441
       1595
        
       #[jacquard_derive::open_union]

     

       1442
       1596
        
       #[derive(

     

       1443
       1597
        
           serde::Serialize,

     
···

       1450
       1604
        
       )]

     

       1451
       1605
        
       #[serde(tag = "$type")]

     

       1452
       1606
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       1453
       1453
       -
       pub enum SubjectStatusViewRecordSubject<'a> {

     

       1607
       1607
       +
       pub enum SubjectStatusViewSubject<'a> {

     

       1454
       1608
        
           #[serde(rename = "com.atproto.admin.defs#repoRef")]

     

       1455
       1455
       -
           DefsRepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       1609
       1609
       +
           RepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       1456
       1610
        
           #[serde(rename = "com.atproto.repo.strongRef")]

     

       1457
       1611
        
           StrongRef(Box<crate::com_atproto::repo::strong_ref::StrongRef<'a>>),

     

       1458
       1612
        
           #[serde(rename = "chat.bsky.convo.defs#messageRef")]

     

       1459
       1459
       -
           DefsMessageRef(Box<crate::chat_bsky::convo::MessageRef<'a>>),

     

       1613
       1613
       +
           MessageRef(Box<crate::chat_bsky::convo::MessageRef<'a>>),

     

       1460
       1614
        
       }

     

       1461
       1615
        
       

     

       1462
       1616
        
       ///Detailed view of a subject. For record subjects, the author's repo and profile will be returned.

     
···

       1474
       1628
        
       pub struct SubjectView<'a> {

     

       1475
       1629
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       1476
       1630
        
           #[serde(borrow)]

     

       1477
       1477
       -
           pub profile: std::option::Option<SubjectViewRecordProfile<'a>>,

     

       1631
       1631
       +
           pub profile: std::option::Option<jacquard_common::types::value::Data<'a>>,

     

       1478
       1632
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       1479
       1633
        
           #[serde(borrow)]

     

       1480
       1634
        
           pub record: std::option::Option<

     
···

       1494
       1648
        
           pub r#type: crate::com_atproto::moderation::SubjectType<'a>,

     

       1495
       1649
        
       }

     

       1496
       1650
        
       

     

       1497
       1497
       -
       #[jacquard_derive::open_union]

     

       1498
       1498
       -
       #[derive(

     

       1499
       1499
       -
           serde::Serialize,

     

       1500
       1500
       -
           serde::Deserialize,

     

       1501
       1501
       -
           Debug,

     

       1502
       1502
       -
           Clone,

     

       1503
       1503
       -
           PartialEq,

     

       1504
       1504
       -
           Eq,

     

       1505
       1505
       -
           jacquard_derive::IntoStatic

     

       1506
       1506
       -
       )]

     

       1507
       1507
       -
       #[serde(tag = "$type")]

     

       1508
       1508
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       1509
       1509
       -
       pub enum SubjectViewRecordProfile<'a> {}

     

       1510
       1651
        
       ///Moderation event timeline event for a PLC create operation

     

       1511
       1652
        
       #[derive(

     

       1512
       1653
        
           serde::Serialize,

+31 -49

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

···

       22
       22
        
           #[serde(borrow)]

     

       23
       23
        
           pub created_by: jacquard_common::types::string::Did<'a>,

     

       24
       24
        
           #[serde(borrow)]

     

       25
       25
       -
           pub event: EmitEventRecordEvent<'a>,

     

       25
       25
       +
           pub event: EmitEventEvent<'a>,

     

       26
       26
        
           ///An optional external ID for the event, used to deduplicate events from external systems. Fails when an event of same type with the same external ID exists for the same subject.

     

       27
       27
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
        
           #[serde(borrow)]

     
···

       32
       32
        
           #[serde(borrow)]

     

       33
       33
        
           pub mod_tool: std::option::Option<crate::tools_ozone::moderation::ModTool<'a>>,

     

       34
       34
        
           #[serde(borrow)]

     

       35
       35
       -
           pub subject: EmitEventRecordSubject<'a>,

     

       35
       35
       +
           pub subject: EmitEventSubject<'a>,

     

       36
       36
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       37
       37
        
           #[serde(borrow)]

     

       38
       38
        
           pub subject_blob_cids: std::option::Option<

     
···

       59
       59
        
       )]

     

       60
       60
        
       #[serde(tag = "$type")]

     

       61
       61
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       62
       62
       -
       pub enum EmitEventRecordEvent<'a> {

     

       62
       62
       +
       pub enum EmitEventEvent<'a> {

     

       63
       63
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventTakedown")]

     

       64
       64
       -
           DefsModEventTakedown(Box<crate::tools_ozone::moderation::ModEventTakedown<'a>>),

     

       64
       64
       +
           ModEventTakedown(Box<crate::tools_ozone::moderation::ModEventTakedown<'a>>),

     

       65
       65
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventAcknowledge")]

     

       66
       66
       -
           DefsModEventAcknowledge(

     

       67
       67
       -
               Box<crate::tools_ozone::moderation::ModEventAcknowledge<'a>>,

     

       68
       68
       -
           ),

     

       66
       66
       +
           ModEventAcknowledge(Box<crate::tools_ozone::moderation::ModEventAcknowledge<'a>>),

     

       69
       67
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventEscalate")]

     

       70
       70
       -
           DefsModEventEscalate(Box<crate::tools_ozone::moderation::ModEventEscalate<'a>>),

     

       68
       68
       +
           ModEventEscalate(Box<crate::tools_ozone::moderation::ModEventEscalate<'a>>),

     

       71
       69
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventComment")]

     

       72
       72
       -
           DefsModEventComment(Box<crate::tools_ozone::moderation::ModEventComment<'a>>),

     

       70
       70
       +
           ModEventComment(Box<crate::tools_ozone::moderation::ModEventComment<'a>>),

     

       73
       71
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventLabel")]

     

       74
       74
       -
           DefsModEventLabel(Box<crate::tools_ozone::moderation::ModEventLabel<'a>>),

     

       72
       72
       +
           ModEventLabel(Box<crate::tools_ozone::moderation::ModEventLabel<'a>>),

     

       75
       73
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventReport")]

     

       76
       76
       -
           DefsModEventReport(Box<crate::tools_ozone::moderation::ModEventReport<'a>>),

     

       74
       74
       +
           ModEventReport(Box<crate::tools_ozone::moderation::ModEventReport<'a>>),

     

       77
       75
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventMute")]

     

       78
       78
       -
           DefsModEventMute(Box<crate::tools_ozone::moderation::ModEventMute<'a>>),

     

       76
       76
       +
           ModEventMute(Box<crate::tools_ozone::moderation::ModEventMute<'a>>),

     

       79
       77
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventUnmute")]

     

       80
       80
       -
           DefsModEventUnmute(Box<crate::tools_ozone::moderation::ModEventUnmute<'a>>),

     

       78
       78
       +
           ModEventUnmute(Box<crate::tools_ozone::moderation::ModEventUnmute<'a>>),

     

       81
       79
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventMuteReporter")]

     

       82
       82
       -
           DefsModEventMuteReporter(

     

       83
       83
       -
               Box<crate::tools_ozone::moderation::ModEventMuteReporter<'a>>,

     

       84
       84
       -
           ),

     

       80
       80
       +
           ModEventMuteReporter(Box<crate::tools_ozone::moderation::ModEventMuteReporter<'a>>),

     

       85
       81
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventUnmuteReporter")]

     

       86
       86
       -
           DefsModEventUnmuteReporter(

     

       82
       82
       +
           ModEventUnmuteReporter(

     

       87
       83
        
               Box<crate::tools_ozone::moderation::ModEventUnmuteReporter<'a>>,

     

       88
       84
        
           ),

     

       89
       85
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventReverseTakedown")]

     

       90
       90
       -
           DefsModEventReverseTakedown(

     

       86
       86
       +
           ModEventReverseTakedown(

     

       91
       87
        
               Box<crate::tools_ozone::moderation::ModEventReverseTakedown<'a>>,

     

       92
       88
        
           ),

     

       93
       89
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventResolveAppeal")]

     

       94
       94
       -
           DefsModEventResolveAppeal(

     

       90
       90
       +
           ModEventResolveAppeal(

     

       95
       91
        
               Box<crate::tools_ozone::moderation::ModEventResolveAppeal<'a>>,

     

       96
       92
        
           ),

     

       97
       93
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventEmail")]

     

       98
       98
       -
           DefsModEventEmail(Box<crate::tools_ozone::moderation::ModEventEmail<'a>>),

     

       94
       94
       +
           ModEventEmail(Box<crate::tools_ozone::moderation::ModEventEmail<'a>>),

     

       99
       95
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventDivert")]

     

       100
       100
       -
           DefsModEventDivert(Box<crate::tools_ozone::moderation::ModEventDivert<'a>>),

     

       96
       96
       +
           ModEventDivert(Box<crate::tools_ozone::moderation::ModEventDivert<'a>>),

     

       101
       97
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventTag")]

     

       102
       102
       -
           DefsModEventTag(Box<crate::tools_ozone::moderation::ModEventTag<'a>>),

     

       98
       98
       +
           ModEventTag(Box<crate::tools_ozone::moderation::ModEventTag<'a>>),

     

       103
       99
        
           #[serde(rename = "tools.ozone.moderation.defs#accountEvent")]

     

       104
       104
       -
           DefsAccountEvent(Box<crate::tools_ozone::moderation::AccountEvent<'a>>),

     

       100
       100
       +
           AccountEvent(Box<crate::tools_ozone::moderation::AccountEvent<'a>>),

     

       105
       101
        
           #[serde(rename = "tools.ozone.moderation.defs#identityEvent")]

     

       106
       106
       -
           DefsIdentityEvent(Box<crate::tools_ozone::moderation::IdentityEvent<'a>>),

     

       102
       102
       +
           IdentityEvent(Box<crate::tools_ozone::moderation::IdentityEvent<'a>>),

     

       107
       103
        
           #[serde(rename = "tools.ozone.moderation.defs#recordEvent")]

     

       108
       108
       -
           DefsRecordEvent(Box<crate::tools_ozone::moderation::RecordEvent<'a>>),

     

       104
       104
       +
           RecordEvent(Box<crate::tools_ozone::moderation::RecordEvent<'a>>),

     

       109
       105
        
           #[serde(rename = "tools.ozone.moderation.defs#modEventPriorityScore")]

     

       110
       110
       -
           DefsModEventPriorityScore(

     

       106
       106
       +
           ModEventPriorityScore(

     

       111
       107
        
               Box<crate::tools_ozone::moderation::ModEventPriorityScore<'a>>,

     

       112
       108
        
           ),

     

       113
       109
        
           #[serde(rename = "tools.ozone.moderation.defs#ageAssuranceEvent")]

     

       114
       114
       -
           DefsAgeAssuranceEvent(Box<crate::tools_ozone::moderation::AgeAssuranceEvent<'a>>),

     

       110
       110
       +
           AgeAssuranceEvent(Box<crate::tools_ozone::moderation::AgeAssuranceEvent<'a>>),

     

       115
       111
        
           #[serde(rename = "tools.ozone.moderation.defs#ageAssuranceOverrideEvent")]

     

       116
       116
       -
           DefsAgeAssuranceOverrideEvent(

     

       112
       112
       +
           AgeAssuranceOverrideEvent(

     

       117
       113
        
               Box<crate::tools_ozone::moderation::AgeAssuranceOverrideEvent<'a>>,

     

       118
       114
        
           ),

     

       119
       115
        
           #[serde(rename = "tools.ozone.moderation.defs#revokeAccountCredentialsEvent")]

     

       120
       120
       -
           DefsRevokeAccountCredentialsEvent(

     

       116
       116
       +
           RevokeAccountCredentialsEvent(

     

       121
       117
        
               Box<crate::tools_ozone::moderation::RevokeAccountCredentialsEvent<'a>>,

     

       122
       118
        
           ),

     

       123
       119
        
           #[serde(rename = "tools.ozone.moderation.defs#scheduleTakedownEvent")]

     

       124
       124
       -
           DefsScheduleTakedownEvent(

     

       120
       120
       +
           ScheduleTakedownEvent(

     

       125
       121
        
               Box<crate::tools_ozone::moderation::ScheduleTakedownEvent<'a>>,

     

       126
       122
        
           ),

     

       127
       123
        
           #[serde(rename = "tools.ozone.moderation.defs#cancelScheduledTakedownEvent")]

     

       128
       128
       -
           DefsCancelScheduledTakedownEvent(

     

       124
       124
       +
           CancelScheduledTakedownEvent(

     

       129
       125
        
               Box<crate::tools_ozone::moderation::CancelScheduledTakedownEvent<'a>>,

     

       130
       126
        
           ),

     

       131
       127
        
       }

     
···

       142
       138
        
       )]

     

       143
       139
        
       #[serde(tag = "$type")]

     

       144
       140
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       145
       145
       -
       pub enum EmitEventRecordSubject<'a> {

     

       141
       141
       +
       pub enum EmitEventSubject<'a> {

     

       146
       142
        
           #[serde(rename = "com.atproto.admin.defs#repoRef")]

     

       147
       147
       -
           DefsRepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       143
       143
       +
           RepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),

     

       148
       144
        
           #[serde(rename = "com.atproto.repo.strongRef")]

     

       149
       145
        
           StrongRef(Box<crate::com_atproto::repo::strong_ref::StrongRef<'a>>),

     

       150
       146
        
       }

     
···

       175
       171
        
           PartialEq,

     

       176
       172
        
           Eq,

     

       177
       173
        
           thiserror::Error,

     

       178
       178
       -
           miette::Diagnostic

     

       174
       174
       +
           miette::Diagnostic,

     

       175
       175
       +
           jacquard_derive::IntoStatic

     

       179
       176
        
       )]

     

       180
       177
        
       #[serde(tag = "error", content = "message")]

     

       181
       178
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       205
       202
        
                       Ok(())

     

       206
       203
        
                   }

     

       207
       204
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       208
       208
       -
               }

     

       209
       209
       -
           }

     

       210
       210
       -
       }

     

       211
       211
       -
       

     

       212
       212
       -
       impl jacquard_common::IntoStatic for EmitEventError<'_> {

     

       213
       213
       -
           type Output = EmitEventError<'static>;

     

       214
       214
       -
           fn into_static(self) -> Self::Output {

     

       215
       215
       -
               match self {

     

       216
       216
       -
                   EmitEventError::SubjectHasAction(v) => {

     

       217
       217
       -
                       EmitEventError::SubjectHasAction(v.into_static())

     

       218
       218
       -
                   }

     

       219
       219
       -
                   EmitEventError::DuplicateExternalId(v) => {

     

       220
       220
       -
                       EmitEventError::DuplicateExternalId(v.into_static())

     

       221
       221
       -
                   }

     

       222
       222
       -
                   EmitEventError::Unknown(v) => EmitEventError::Unknown(v.into_static()),

     

       223
       205
        
               }

     

       224
       206
        
           }

     

       225
       207
        
       }

+2 -15

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

···

       47
       47
        
           PartialEq,

     

       48
       48
        
           Eq,

     

       49
       49
        
           thiserror::Error,

     

       50
       50
       -
           miette::Diagnostic

     

       50
       50
       +
           miette::Diagnostic,

     

       51
       51
       +
           jacquard_derive::IntoStatic

     

       51
       52
        
       )]

     

       52
       53
        
       #[serde(tag = "error", content = "message")]

     

       53
       54
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       67
       68
        
                       Ok(())

     

       68
       69
        
                   }

     

       69
       70
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       70
       70
       -
               }

     

       71
       71
       -
           }

     

       72
       72
       -
       }

     

       73
       73
       -
       

     

       74
       74
       -
       impl jacquard_common::IntoStatic for GetAccountTimelineError<'_> {

     

       75
       75
       -
           type Output = GetAccountTimelineError<'static>;

     

       76
       76
       -
           fn into_static(self) -> Self::Output {

     

       77
       77
       -
               match self {

     

       78
       78
       -
                   GetAccountTimelineError::RepoNotFound(v) => {

     

       79
       79
       -
                       GetAccountTimelineError::RepoNotFound(v.into_static())

     

       80
       80
       -
                   }

     

       81
       81
       -
                   GetAccountTimelineError::Unknown(v) => {

     

       82
       82
       -
                       GetAccountTimelineError::Unknown(v.into_static())

     

       83
       83
       -
                   }

     

       84
       71
        
               }

     

       85
       72
        
           }

     

       86
       73
        
       }

+2 -13

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

···

       51
       51
        
           PartialEq,

     

       52
       52
        
           Eq,

     

       53
       53
        
           thiserror::Error,

     

       54
       54
       -
           miette::Diagnostic

     

       54
       54
       +
           miette::Diagnostic,

     

       55
       55
       +
           jacquard_derive::IntoStatic

     

       55
       56
        
       )]

     

       56
       57
        
       #[serde(tag = "error", content = "message")]

     

       57
       58
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       71
       72
        
                       Ok(())

     

       72
       73
        
                   }

     

       73
       74
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       74
       74
       -
               }

     

       75
       75
       -
           }

     

       76
       76
       -
       }

     

       77
       77
       -
       

     

       78
       78
       -
       impl jacquard_common::IntoStatic for GetRecordError<'_> {

     

       79
       79
       -
           type Output = GetRecordError<'static>;

     

       80
       80
       -
           fn into_static(self) -> Self::Output {

     

       81
       81
       -
               match self {

     

       82
       82
       -
                   GetRecordError::RecordNotFound(v) => {

     

       83
       83
       -
                       GetRecordError::RecordNotFound(v.into_static())

     

       84
       84
       -
                   }

     

       85
       85
       -
                   GetRecordError::Unknown(v) => GetRecordError::Unknown(v.into_static()),

     

       86
       75
        
               }

     

       87
       76
        
           }

     

       88
       77
        
       }

+20 -1

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

···

       35
       35
        
       #[serde(rename_all = "camelCase")]

     

       36
       36
        
       pub struct GetRecordsOutput<'a> {

     

       37
       37
        
           #[serde(borrow)]

     

       38
       38
       -
           pub records: Vec<jacquard_common::types::value::Data<'a>>,

     

       38
       38
       +
           pub records: Vec<GetRecordsOutputRecordsItem<'a>>,

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       #[jacquard_derive::open_union]

     

       42
       42
       +
       #[derive(

     

       43
       43
       +
           serde::Serialize,

     

       44
       44
       +
           serde::Deserialize,

     

       45
       45
       +
           Debug,

     

       46
       46
       +
           Clone,

     

       47
       47
       +
           PartialEq,

     

       48
       48
       +
           Eq,

     

       49
       49
       +
           jacquard_derive::IntoStatic

     

       50
       50
       +
       )]

     

       51
       51
       +
       #[serde(tag = "$type")]

     

       52
       52
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       53
       53
       +
       pub enum GetRecordsOutputRecordsItem<'a> {

     

       54
       54
       +
           #[serde(rename = "tools.ozone.moderation.defs#recordViewDetail")]

     

       55
       55
       +
           RecordViewDetail(Box<crate::tools_ozone::moderation::RecordViewDetail<'a>>),

     

       56
       56
       +
           #[serde(rename = "tools.ozone.moderation.defs#recordViewNotFound")]

     

       57
       57
       +
           RecordViewNotFound(Box<crate::tools_ozone::moderation::RecordViewNotFound<'a>>),

     

       39
       58
        
       }

     

       40
       59
        
       

     

       41
       60
        
       ///Response type for

+2 -11

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

···

       48
       48
        
           PartialEq,

     

       49
       49
        
           Eq,

     

       50
       50
        
           thiserror::Error,

     

       51
       51
       -
           miette::Diagnostic

     

       51
       51
       +
           miette::Diagnostic,

     

       52
       52
       +
           jacquard_derive::IntoStatic

     

       52
       53
        
       )]

     

       53
       54
        
       #[serde(tag = "error", content = "message")]

     

       54
       55
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       68
       69
        
                       Ok(())

     

       69
       70
        
                   }

     

       70
       71
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       71
       71
       -
               }

     

       72
       72
       -
           }

     

       73
       73
       -
       }

     

       74
       74
       -
       

     

       75
       75
       -
       impl jacquard_common::IntoStatic for GetRepoError<'_> {

     

       76
       76
       -
           type Output = GetRepoError<'static>;

     

       77
       77
       -
           fn into_static(self) -> Self::Output {

     

       78
       78
       -
               match self {

     

       79
       79
       -
                   GetRepoError::RepoNotFound(v) => GetRepoError::RepoNotFound(v.into_static()),

     

       80
       80
       -
                   GetRepoError::Unknown(v) => GetRepoError::Unknown(v.into_static()),

     

       81
       72
        
               }

     

       82
       73
        
           }

     

       83
       74
        
       }

+20 -1

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

···

       35
       35
        
       #[serde(rename_all = "camelCase")]

     

       36
       36
        
       pub struct GetReposOutput<'a> {

     

       37
       37
        
           #[serde(borrow)]

     

       38
       38
       -
           pub repos: Vec<jacquard_common::types::value::Data<'a>>,

     

       38
       38
       +
           pub repos: Vec<GetReposOutputReposItem<'a>>,

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       #[jacquard_derive::open_union]

     

       42
       42
       +
       #[derive(

     

       43
       43
       +
           serde::Serialize,

     

       44
       44
       +
           serde::Deserialize,

     

       45
       45
       +
           Debug,

     

       46
       46
       +
           Clone,

     

       47
       47
       +
           PartialEq,

     

       48
       48
       +
           Eq,

     

       49
       49
       +
           jacquard_derive::IntoStatic

     

       50
       50
       +
       )]

     

       51
       51
       +
       #[serde(tag = "$type")]

     

       52
       52
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       53
       53
       +
       pub enum GetReposOutputReposItem<'a> {

     

       54
       54
       +
           #[serde(rename = "tools.ozone.moderation.defs#repoViewDetail")]

     

       55
       55
       +
           RepoViewDetail(Box<crate::tools_ozone::moderation::RepoViewDetail<'a>>),

     

       56
       56
       +
           #[serde(rename = "tools.ozone.moderation.defs#repoViewNotFound")]

     

       57
       57
       +
           RepoViewNotFound(Box<crate::tools_ozone::moderation::RepoViewNotFound<'a>>),

     

       39
       58
        
       }

     

       40
       59
        
       

     

       41
       60
        
       ///Response type for

+1 -14

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

···

       41
       41
        
       #[builder(start_fn = new)]

     

       42
       42
        
       pub struct ScheduleAction<'a> {

     

       43
       43
        
           #[serde(borrow)]

     

       44
       44
       -
           pub action: ScheduleActionRecordAction<'a>,

     

       44
       44
       +
           pub action: jacquard_common::types::value::Data<'a>,

     

       45
       45
        
           #[serde(borrow)]

     

       46
       46
        
           pub created_by: jacquard_common::types::string::Did<'a>,

     

       47
       47
        
           ///This will be propagated to the moderation event when it is applied

     
···

       62
       62
        
           >,

     

       63
       63
        
       }

     

       64
       64
        
       

     

       65
       65
       -
       #[jacquard_derive::open_union]

     

       66
       66
       -
       #[derive(

     

       67
       67
       -
           serde::Serialize,

     

       68
       68
       -
           serde::Deserialize,

     

       69
       69
       -
           Debug,

     

       70
       70
       -
           Clone,

     

       71
       71
       -
           PartialEq,

     

       72
       72
       -
           Eq,

     

       73
       73
       -
           jacquard_derive::IntoStatic

     

       74
       74
       -
       )]

     

       75
       75
       -
       #[serde(tag = "$type")]

     

       76
       76
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       77
       77
       -
       pub enum ScheduleActionRecordAction<'a> {}

     

       78
       65
        
       #[jacquard_derive::lexicon]

     

       79
       66
        
       #[derive(

     

       80
       67
        
           serde::Serialize,

+2 -14

crates/jacquard-api/src/tools_ozone/safelink/add_rule.rs

···

       73
       73
        
           PartialEq,

     

       74
       74
        
           Eq,

     

       75
       75
        
           thiserror::Error,

     

       76
       76
       -
           miette::Diagnostic

     

       76
       76
       +
           miette::Diagnostic,

     

       77
       77
       +
           jacquard_derive::IntoStatic

     

       77
       78
        
       )]

     

       78
       79
        
       #[serde(tag = "error", content = "message")]

     

       79
       80
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       104
       105
        
                       Ok(())

     

       105
       106
        
                   }

     

       106
       107
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       107
       107
       -
               }

     

       108
       108
       -
           }

     

       109
       109
       -
       }

     

       110
       110
       -
       

     

       111
       111
       -
       impl jacquard_common::IntoStatic for AddRuleError<'_> {

     

       112
       112
       -
           type Output = AddRuleError<'static>;

     

       113
       113
       -
           fn into_static(self) -> Self::Output {

     

       114
       114
       -
               match self {

     

       115
       115
       -
                   AddRuleError::InvalidUrl(v) => AddRuleError::InvalidUrl(v.into_static()),

     

       116
       116
       -
                   AddRuleError::RuleAlreadyExists(v) => {

     

       117
       117
       -
                       AddRuleError::RuleAlreadyExists(v.into_static())

     

       118
       118
       -
                   }

     

       119
       119
       -
                   AddRuleError::Unknown(v) => AddRuleError::Unknown(v.into_static()),

     

       120
       108
        
               }

     

       121
       109
        
           }

     

       122
       110
        
       }

+2 -13

crates/jacquard-api/src/tools_ozone/safelink/remove_rule.rs

···

       69
       69
        
           PartialEq,

     

       70
       70
        
           Eq,

     

       71
       71
        
           thiserror::Error,

     

       72
       72
       -
           miette::Diagnostic

     

       72
       72
       +
           miette::Diagnostic,

     

       73
       73
       +
           jacquard_derive::IntoStatic

     

       73
       74
        
       )]

     

       74
       75
        
       #[serde(tag = "error", content = "message")]

     

       75
       76
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       90
       91
        
                       Ok(())

     

       91
       92
        
                   }

     

       92
       93
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       93
       93
       -
               }

     

       94
       94
       -
           }

     

       95
       95
       -
       }

     

       96
       96
       -
       

     

       97
       97
       -
       impl jacquard_common::IntoStatic for RemoveRuleError<'_> {

     

       98
       98
       -
           type Output = RemoveRuleError<'static>;

     

       99
       99
       -
           fn into_static(self) -> Self::Output {

     

       100
       100
       -
               match self {

     

       101
       101
       -
                   RemoveRuleError::RuleNotFound(v) => {

     

       102
       102
       -
                       RemoveRuleError::RuleNotFound(v.into_static())

     

       103
       103
       -
                   }

     

       104
       104
       -
                   RemoveRuleError::Unknown(v) => RemoveRuleError::Unknown(v.into_static()),

     

       105
       94
        
               }

     

       106
       95
        
           }

     

       107
       96
        
       }

+2 -13

crates/jacquard-api/src/tools_ozone/safelink/update_rule.rs

···

       73
       73
        
           PartialEq,

     

       74
       74
        
           Eq,

     

       75
       75
        
           thiserror::Error,

     

       76
       76
       -
           miette::Diagnostic

     

       76
       76
       +
           miette::Diagnostic,

     

       77
       77
       +
           jacquard_derive::IntoStatic

     

       77
       78
        
       )]

     

       78
       79
        
       #[serde(tag = "error", content = "message")]

     

       79
       80
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       94
       95
        
                       Ok(())

     

       95
       96
        
                   }

     

       96
       97
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       97
       97
       -
               }

     

       98
       98
       -
           }

     

       99
       99
       -
       }

     

       100
       100
       -
       

     

       101
       101
       -
       impl jacquard_common::IntoStatic for UpdateRuleError<'_> {

     

       102
       102
       -
           type Output = UpdateRuleError<'static>;

     

       103
       103
       -
           fn into_static(self) -> Self::Output {

     

       104
       104
       -
               match self {

     

       105
       105
       -
                   UpdateRuleError::RuleNotFound(v) => {

     

       106
       106
       -
                       UpdateRuleError::RuleNotFound(v.into_static())

     

       107
       107
       -
                   }

     

       108
       108
       -
                   UpdateRuleError::Unknown(v) => UpdateRuleError::Unknown(v.into_static()),

     

       109
       98
        
               }

     

       110
       99
        
           }

     

       111
       100
        
       }

+2 -13

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

···

       53
       53
        
           PartialEq,

     

       54
       54
        
           Eq,

     

       55
       55
        
           thiserror::Error,

     

       56
       56
       -
           miette::Diagnostic

     

       56
       56
       +
           miette::Diagnostic,

     

       57
       57
       +
           jacquard_derive::IntoStatic

     

       57
       58
        
       )]

     

       58
       59
        
       #[serde(tag = "error", content = "message")]

     

       59
       60
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       74
       75
        
                       Ok(())

     

       75
       76
        
                   }

     

       76
       77
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       77
       77
       -
               }

     

       78
       78
       -
           }

     

       79
       79
       -
       }

     

       80
       80
       -
       

     

       81
       81
       -
       impl jacquard_common::IntoStatic for DeleteSetError<'_> {

     

       82
       82
       -
           type Output = DeleteSetError<'static>;

     

       83
       83
       -
           fn into_static(self) -> Self::Output {

     

       84
       84
       -
               match self {

     

       85
       85
       -
                   DeleteSetError::SetNotFound(v) => {

     

       86
       86
       -
                       DeleteSetError::SetNotFound(v.into_static())

     

       87
       87
       -
                   }

     

       88
       88
       -
                   DeleteSetError::Unknown(v) => DeleteSetError::Unknown(v.into_static()),

     

       89
       78
        
               }

     

       90
       79
        
           }

     

       91
       80
        
       }

+2 -13

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

···

       44
       44
        
           PartialEq,

     

       45
       45
        
           Eq,

     

       46
       46
        
           thiserror::Error,

     

       47
       47
       -
           miette::Diagnostic

     

       47
       47
       +
           miette::Diagnostic,

     

       48
       48
       +
           jacquard_derive::IntoStatic

     

       48
       49
        
       )]

     

       49
       50
        
       #[serde(tag = "error", content = "message")]

     

       50
       51
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       65
       66
        
                       Ok(())

     

       66
       67
        
                   }

     

       67
       68
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       68
       68
       -
               }

     

       69
       69
       -
           }

     

       70
       70
       -
       }

     

       71
       71
       -
       

     

       72
       72
       -
       impl jacquard_common::IntoStatic for DeleteValuesError<'_> {

     

       73
       73
       -
           type Output = DeleteValuesError<'static>;

     

       74
       74
       -
           fn into_static(self) -> Self::Output {

     

       75
       75
       -
               match self {

     

       76
       76
       -
                   DeleteValuesError::SetNotFound(v) => {

     

       77
       77
       -
                       DeleteValuesError::SetNotFound(v.into_static())

     

       78
       78
       -
                   }

     

       79
       79
       -
                   DeleteValuesError::Unknown(v) => DeleteValuesError::Unknown(v.into_static()),

     

       80
       69
        
               }

     

       81
       70
        
           }

     

       82
       71
        
       }

+2 -13

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

···

       60
       60
        
           PartialEq,

     

       61
       61
        
           Eq,

     

       62
       62
        
           thiserror::Error,

     

       63
       63
       -
           miette::Diagnostic

     

       63
       63
       +
           miette::Diagnostic,

     

       64
       64
       +
           jacquard_derive::IntoStatic

     

       64
       65
        
       )]

     

       65
       66
        
       #[serde(tag = "error", content = "message")]

     

       66
       67
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       81
       82
        
                       Ok(())

     

       82
       83
        
                   }

     

       83
       84
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       84
       84
       -
               }

     

       85
       85
       -
           }

     

       86
       86
       -
       }

     

       87
       87
       -
       

     

       88
       88
       -
       impl jacquard_common::IntoStatic for GetValuesError<'_> {

     

       89
       89
       -
           type Output = GetValuesError<'static>;

     

       90
       90
       -
           fn into_static(self) -> Self::Output {

     

       91
       91
       -
               match self {

     

       92
       92
       -
                   GetValuesError::SetNotFound(v) => {

     

       93
       93
       -
                       GetValuesError::SetNotFound(v.into_static())

     

       94
       94
       -
                   }

     

       95
       95
       -
                   GetValuesError::Unknown(v) => GetValuesError::Unknown(v.into_static()),

     

       96
       85
        
               }

     

       97
       86
        
           }

     

       98
       87
        
       }

+2 -13

crates/jacquard-api/src/tools_ozone/team/add_member.rs

···

       59
       59
        
           PartialEq,

     

       60
       60
        
           Eq,

     

       61
       61
        
           thiserror::Error,

     

       62
       62
       -
           miette::Diagnostic

     

       62
       62
       +
           miette::Diagnostic,

     

       63
       63
       +
           jacquard_derive::IntoStatic

     

       63
       64
        
       )]

     

       64
       65
        
       #[serde(tag = "error", content = "message")]

     

       65
       66
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       80
       81
        
                       Ok(())

     

       81
       82
        
                   }

     

       82
       83
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       83
       83
       -
               }

     

       84
       84
       -
           }

     

       85
       85
       -
       }

     

       86
       86
       -
       

     

       87
       87
       -
       impl jacquard_common::IntoStatic for AddMemberError<'_> {

     

       88
       88
       -
           type Output = AddMemberError<'static>;

     

       89
       89
       -
           fn into_static(self) -> Self::Output {

     

       90
       90
       -
               match self {

     

       91
       91
       -
                   AddMemberError::MemberAlreadyExists(v) => {

     

       92
       92
       -
                       AddMemberError::MemberAlreadyExists(v.into_static())

     

       93
       93
       -
                   }

     

       94
       94
       -
                   AddMemberError::Unknown(v) => AddMemberError::Unknown(v.into_static()),

     

       95
       84
        
               }

     

       96
       85
        
           }

     

       97
       86
        
       }

+2 -16

crates/jacquard-api/src/tools_ozone/team/delete_member.rs

···

       39
       39
        
           PartialEq,

     

       40
       40
        
           Eq,

     

       41
       41
        
           thiserror::Error,

     

       42
       42
       -
           miette::Diagnostic

     

       42
       42
       +
           miette::Diagnostic,

     

       43
       43
       +
           jacquard_derive::IntoStatic

     

       43
       44
        
       )]

     

       44
       45
        
       #[serde(tag = "error", content = "message")]

     

       45
       46
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       70
       71
        
                       Ok(())

     

       71
       72
        
                   }

     

       72
       73
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       73
       73
       -
               }

     

       74
       74
       -
           }

     

       75
       75
       -
       }

     

       76
       76
       -
       

     

       77
       77
       -
       impl jacquard_common::IntoStatic for DeleteMemberError<'_> {

     

       78
       78
       -
           type Output = DeleteMemberError<'static>;

     

       79
       79
       -
           fn into_static(self) -> Self::Output {

     

       80
       80
       -
               match self {

     

       81
       81
       -
                   DeleteMemberError::MemberNotFound(v) => {

     

       82
       82
       -
                       DeleteMemberError::MemberNotFound(v.into_static())

     

       83
       83
       -
                   }

     

       84
       84
       -
                   DeleteMemberError::CannotDeleteSelf(v) => {

     

       85
       85
       -
                       DeleteMemberError::CannotDeleteSelf(v.into_static())

     

       86
       86
       -
                   }

     

       87
       87
       -
                   DeleteMemberError::Unknown(v) => DeleteMemberError::Unknown(v.into_static()),

     

       88
       74
        
               }

     

       89
       75
        
           }

     

       90
       76
        
       }

+2 -13

crates/jacquard-api/src/tools_ozone/team/update_member.rs

···

       62
       62
        
           PartialEq,

     

       63
       63
        
           Eq,

     

       64
       64
        
           thiserror::Error,

     

       65
       65
       -
           miette::Diagnostic

     

       65
       65
       +
           miette::Diagnostic,

     

       66
       66
       +
           jacquard_derive::IntoStatic

     

       66
       67
        
       )]

     

       67
       68
        
       #[serde(tag = "error", content = "message")]

     

       68
       69
        
       #[serde(bound(deserialize = "'de: 'a"))]

     
···

       83
       84
        
                       Ok(())

     

       84
       85
        
                   }

     

       85
       86
        
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       86
       86
       -
               }

     

       87
       87
       -
           }

     

       88
       88
       -
       }

     

       89
       89
       -
       

     

       90
       90
       -
       impl jacquard_common::IntoStatic for UpdateMemberError<'_> {

     

       91
       91
       -
           type Output = UpdateMemberError<'static>;

     

       92
       92
       -
           fn into_static(self) -> Self::Output {

     

       93
       93
       -
               match self {

     

       94
       94
       -
                   UpdateMemberError::MemberNotFound(v) => {

     

       95
       95
       -
                       UpdateMemberError::MemberNotFound(v.into_static())

     

       96
       96
       -
                   }

     

       97
       97
       -
                   UpdateMemberError::Unknown(v) => UpdateMemberError::Unknown(v.into_static()),

     

       98
       87
        
               }

     

       99
       88
        
           }

     

       100
       89
        
       }

+10 -36

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

···

       35
       35
        
           pub issuer: jacquard_common::types::string::Did<'a>,

     

       36
       36
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       37
       37
        
           #[serde(borrow)]

     

       38
       38
       -
           pub issuer_profile: std::option::Option<VerificationViewRecordIssuerProfile<'a>>,

     

       38
       38
       +
           pub issuer_profile: std::option::Option<jacquard_common::types::value::Data<'a>>,

     

       39
       39
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       40
       40
        
           #[serde(borrow)]

     

       41
       41
       -
           pub issuer_repo: std::option::Option<VerificationViewRecordIssuerRepo<'a>>,

     

       41
       41
       +
           pub issuer_repo: std::option::Option<VerificationViewIssuerRepo<'a>>,

     

       42
       42
        
           ///Describes the reason for revocation, also indicating that the verification is no longer valid.

     

       43
       43
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       44
       44
        
           #[serde(borrow)]

     
···

       55
       55
        
           pub subject: jacquard_common::types::string::Did<'a>,

     

       56
       56
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       57
       57
        
           #[serde(borrow)]

     

       58
       58
       -
           pub subject_profile: std::option::Option<VerificationViewRecordSubjectProfile<'a>>,

     

       58
       58
       +
           pub subject_profile: std::option::Option<jacquard_common::types::value::Data<'a>>,

     

       59
       59
        
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       60
       60
        
           #[serde(borrow)]

     

       61
       61
       -
           pub subject_repo: std::option::Option<VerificationViewRecordSubjectRepo<'a>>,

     

       61
       61
       +
           pub subject_repo: std::option::Option<VerificationViewSubjectRepo<'a>>,

     

       62
       62
        
           ///The AT-URI of the verification record.

     

       63
       63
        
           #[serde(borrow)]

     

       64
       64
        
           pub uri: jacquard_common::types::string::AtUri<'a>,

     
···

       76
       76
        
       )]

     

       77
       77
        
       #[serde(tag = "$type")]

     

       78
       78
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       79
       79
       -
       pub enum VerificationViewRecordIssuerProfile<'a> {}

     

       80
       80
       -
       #[jacquard_derive::open_union]

     

       81
       81
       -
       #[derive(

     

       82
       82
       -
           serde::Serialize,

     

       83
       83
       -
           serde::Deserialize,

     

       84
       84
       -
           Debug,

     

       85
       85
       -
           Clone,

     

       86
       86
       -
           PartialEq,

     

       87
       87
       -
           Eq,

     

       88
       88
       -
           jacquard_derive::IntoStatic

     

       89
       89
       -
       )]

     

       90
       90
       -
       #[serde(tag = "$type")]

     

       91
       91
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       92
       92
       -
       pub enum VerificationViewRecordIssuerRepo<'a> {

     

       79
       79
       +
       pub enum VerificationViewIssuerRepo<'a> {

     

       93
       80
        
           #[serde(rename = "tools.ozone.moderation.defs#repoViewDetail")]

     

       94
       94
       -
           DefsRepoViewDetail(Box<crate::tools_ozone::moderation::RepoViewDetail<'a>>),

     

       81
       81
       +
           RepoViewDetail(Box<crate::tools_ozone::moderation::RepoViewDetail<'a>>),

     

       95
       82
        
           #[serde(rename = "tools.ozone.moderation.defs#repoViewNotFound")]

     

       96
       96
       -
           DefsRepoViewNotFound(Box<crate::tools_ozone::moderation::RepoViewNotFound<'a>>),

     

       83
       83
       +
           RepoViewNotFound(Box<crate::tools_ozone::moderation::RepoViewNotFound<'a>>),

     

       97
       84
        
       }

     

       98
       85
        
       

     

       99
       86
        
       #[jacquard_derive::open_union]

     
···

       108
       95
        
       )]

     

       109
       96
        
       #[serde(tag = "$type")]

     

       110
       97
        
       #[serde(bound(deserialize = "'de: 'a"))]

     

       111
       111
       -
       pub enum VerificationViewRecordSubjectProfile<'a> {}

     

       112
       112
       -
       #[jacquard_derive::open_union]

     

       113
       113
       -
       #[derive(

     

       114
       114
       -
           serde::Serialize,

     

       115
       115
       -
           serde::Deserialize,

     

       116
       116
       -
           Debug,

     

       117
       117
       -
           Clone,

     

       118
       118
       -
           PartialEq,

     

       119
       119
       -
           Eq,

     

       120
       120
       -
           jacquard_derive::IntoStatic

     

       121
       121
       -
       )]

     

       122
       122
       -
       #[serde(tag = "$type")]

     

       123
       123
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       124
       124
       -
       pub enum VerificationViewRecordSubjectRepo<'a> {

     

       98
       98
       +
       pub enum VerificationViewSubjectRepo<'a> {

     

       125
       99
        
           #[serde(rename = "tools.ozone.moderation.defs#repoViewDetail")]

     

       126
       126
       -
           DefsRepoViewDetail(Box<crate::tools_ozone::moderation::RepoViewDetail<'a>>),

     

       100
       100
       +
           RepoViewDetail(Box<crate::tools_ozone::moderation::RepoViewDetail<'a>>),

     

       127
       101
        
           #[serde(rename = "tools.ozone.moderation.defs#repoViewNotFound")]

     

       128
       128
       -
           DefsRepoViewNotFound(Box<crate::tools_ozone::moderation::RepoViewNotFound<'a>>),

     

       102
       102
       +
           RepoViewNotFound(Box<crate::tools_ozone::moderation::RepoViewNotFound<'a>>),

     

       129
       103
        
       }

+1 -18

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

···

       19
       19
        
       #[serde(rename_all = "camelCase")]

     

       20
       20
        
       pub struct Preference<'a> {

     

       21
       21
        
           #[serde(borrow)]

     

       22
       22
       -
           pub my_page: PreferenceRecordMyPage<'a>,

     

       23
       23
       -
       }

     

       24
       24
       -
       

     

       25
       25
       -
       #[jacquard_derive::open_union]

     

       26
       26
       -
       #[derive(

     

       27
       27
       -
           serde::Serialize,

     

       28
       28
       -
           serde::Deserialize,

     

       29
       29
       -
           Debug,

     

       30
       30
       -
           Clone,

     

       31
       31
       -
           PartialEq,

     

       32
       32
       -
           Eq,

     

       33
       33
       -
           jacquard_derive::IntoStatic

     

       34
       34
       -
       )]

     

       35
       35
       -
       #[serde(tag = "$type")]

     

       36
       36
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       37
       37
       -
       pub enum PreferenceRecordMyPage<'a> {

     

       38
       38
       -
           #[serde(rename = "uk.skyblur.preference#myPage")]

     

       39
       39
       -
           PreferenceMyPage(Box<crate::uk_skyblur::preference::MyPage<'a>>),

     

       22
       22
       +
           pub my_page: crate::uk_skyblur::preference::MyPage<'a>,

     

       40
       23
        
       }

     

       41
       24
        
       

     

       42
       25
        
       impl jacquard_common::types::collection::Collection for Preference<'_> {

+51 -1

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

···

       1
       1
        
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
        
       //

     

       3
       3
       +
       // Lexicon: win.tomo-x.pushat.defs

     

       4
       4
       +
       //

     

       3
       5
        
       // This file was automatically generated from Lexicon schemas.

     

       4
       6
        
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       7
        
       

     

       6
       6
       -
       pub mod push_notify;
     

       8
       8
       +
       pub mod allow;

     

       9
       9
       +
       pub mod push_notify;

     

       10
       10
       +
       

     

       11
       11
       +
       pub type DeviceList<'a> = Vec<crate::win_tomo_x::pushat::DeviceListItem<'a>>;

     

       12
       12
       +
       #[jacquard_derive::lexicon]

     

       13
       13
       +
       #[derive(

     

       14
       14
       +
           serde::Serialize,

     

       15
       15
       +
           serde::Deserialize,

     

       16
       16
       +
           Debug,

     

       17
       17
       +
           Clone,

     

       18
       18
       +
           PartialEq,

     

       19
       19
       +
           Eq,

     

       20
       20
       +
           jacquard_derive::IntoStatic

     

       21
       21
       +
       )]

     

       22
       22
       +
       #[serde(rename_all = "camelCase")]

     

       23
       23
       +
       pub struct DeviceListItem<'a> {

     

       24
       24
       +
           pub current: bool,

     

       25
       25
       +
           pub id: jacquard_common::types::string::Tid,

     

       26
       26
       +
           #[serde(borrow)]

     

       27
       27
       +
           pub name: jacquard_common::CowStr<'a>,

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       #[jacquard_derive::lexicon]

     

       31
       31
       +
       #[derive(

     

       32
       32
       +
           serde::Serialize,

     

       33
       33
       +
           serde::Deserialize,

     

       34
       34
       +
           Debug,

     

       35
       35
       +
           Clone,

     

       36
       36
       +
           PartialEq,

     

       37
       37
       +
           Eq,

     

       38
       38
       +
           jacquard_derive::IntoStatic

     

       39
       39
       +
       )]

     

       40
       40
       +
       #[serde(rename_all = "camelCase")]

     

       41
       41
       +
       pub struct NotifyBody<'a> {

     

       42
       42
       +
           ///Body text of the notification.

     

       43
       43
       +
           #[serde(borrow)]

     

       44
       44
       +
           pub body: jacquard_common::CowStr<'a>,

     

       45
       45
       +
           ///The URI of the icon displayed in the notification.

     

       46
       46
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       47
       47
       +
           #[serde(borrow)]

     

       48
       48
       +
           pub icon: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       49
       49
       +
           ///Experimental — do not use. The URI to open when the notification is clicked.

     

       50
       50
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       51
       51
       +
           #[serde(borrow)]

     

       52
       52
       +
           pub link: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       53
       53
       +
           ///Title text of the notification.

     

       54
       54
       +
           #[serde(borrow)]

     

       55
       55
       +
           pub title: jacquard_common::CowStr<'a>,

     

       56
       56
       +
       }

+46 -2

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

···

       20
       20
        
       #[builder(start_fn = new)]

     

       21
       21
        
       pub struct PushNotify<'a> {

     

       22
       22
        
           #[serde(borrow)]

     

       23
       23
       -
           pub body: jacquard_common::types::value::Data<'a>,

     

       23
       23
       +
           pub body: crate::win_tomo_x::pushat::NotifyBody<'a>,

     

       24
       24
       +
           ///The DID of the target user to whom the notification will be sent.

     

       24
       25
        
           #[serde(borrow)]

     

       25
       26
        
           pub target: jacquard_common::types::string::Did<'a>,

     

       26
       27
        
           #[serde(flatten)]

     
···

       44
       45
        
       )]

     

       45
       46
        
       #[serde(rename_all = "camelCase")]

     

       46
       47
        
       pub struct PushNotifyOutput<'a> {}

     

       48
       48
       +
       #[jacquard_derive::open_union]

     

       49
       49
       +
       #[derive(

     

       50
       50
       +
           serde::Serialize,

     

       51
       51
       +
           serde::Deserialize,

     

       52
       52
       +
           Debug,

     

       53
       53
       +
           Clone,

     

       54
       54
       +
           PartialEq,

     

       55
       55
       +
           Eq,

     

       56
       56
       +
           thiserror::Error,

     

       57
       57
       +
           miette::Diagnostic,

     

       58
       58
       +
           jacquard_derive::IntoStatic

     

       59
       59
       +
       )]

     

       60
       60
       +
       #[serde(tag = "error", content = "message")]

     

       61
       61
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       62
       62
       +
       pub enum PushNotifyError<'a> {

     

       63
       63
       +
           #[serde(rename = "ServiceNotAllowedError")]

     

       64
       64
       +
           ServiceNotAllowedError(std::option::Option<String>),

     

       65
       65
       +
           #[serde(rename = "DeviceNotFoundError")]

     

       66
       66
       +
           DeviceNotFoundError(std::option::Option<String>),

     

       67
       67
       +
       }

     

       68
       68
       +
       

     

       69
       69
       +
       impl std::fmt::Display for PushNotifyError<'_> {

     

       70
       70
       +
           fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

     

       71
       71
       +
               match self {

     

       72
       72
       +
                   Self::ServiceNotAllowedError(msg) => {

     

       73
       73
       +
                       write!(f, "ServiceNotAllowedError")?;

     

       74
       74
       +
                       if let Some(msg) = msg {

     

       75
       75
       +
                           write!(f, ": {}", msg)?;

     

       76
       76
       +
                       }

     

       77
       77
       +
                       Ok(())

     

       78
       78
       +
                   }

     

       79
       79
       +
                   Self::DeviceNotFoundError(msg) => {

     

       80
       80
       +
                       write!(f, "DeviceNotFoundError")?;

     

       81
       81
       +
                       if let Some(msg) = msg {

     

       82
       82
       +
                           write!(f, ": {}", msg)?;

     

       83
       83
       +
                       }

     

       84
       84
       +
                       Ok(())

     

       85
       85
       +
                   }

     

       86
       86
       +
                   Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       87
       87
       +
               }

     

       88
       88
       +
           }

     

       89
       89
       +
       }

     

       90
       90
       +
       

     

       47
       91
        
       ///Response type for

     

       48
       92
        
       ///win.tomo-x.pushat.pushNotify

     

       49
       93
        
       pub struct PushNotifyResponse;

     
···

       51
       95
        
           const NSID: &'static str = "win.tomo-x.pushat.pushNotify";

     

       52
       96
        
           const ENCODING: &'static str = "application/json";

     

       53
       97
        
           type Output<'de> = PushNotifyOutput<'de>;

     

       54
       54
       -
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       98
       98
       +
           type Err<'de> = PushNotifyError<'de>;

     

       55
       99
        
       }

     

       56
       100
        
       

     

       57
       101
        
       impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for PushNotify<'de> {

+3 -3

crates/jacquard-lexicon/Cargo.toml

···

       25
       25
        
       glob = "0.3"

     

       26
       26
        
       heck.workspace = true

     

       27
       27
        
       itertools.workspace = true

     

       28
       28
       -
       jacquard-api = {  version = "0.4", path = "../jacquard-api" }

     

       29
       29
       -
       jacquard-common = { version = "0.4", path = "../jacquard-common" }

     

       30
       30
       -
       jacquard-identity = { version = "0.4", path = "../jacquard-identity" }

     

       28
       28
       +
       jacquard-api = {  version = "0.4", git = "https://tangled.org/@nonbinary.computer/jacquard" }

     

       29
       29
       +
       jacquard-common = { version = "0.4", git = "https://tangled.org/@nonbinary.computer/jacquard" }

     

       30
       30
       +
       jacquard-identity = { version = "0.4", git = "https://tangled.org/@nonbinary.computer/jacquard" }

     

       31
       31
        
       kdl = "6"

     

       32
       32
        
       miette = { workspace = true, features = ["fancy"] }

     

       33
       33
        
       prettyplease.workspace = true

+49 -2574

crates/jacquard-lexicon/src/codegen.rs

···

       1
       1
        
       use crate::corpus::LexiconCorpus;

     

       2
       2
        
       use crate::error::{CodegenError, Result};

     

       3
       3
       -
       use crate::lexicon::{

     

       4
       4
       -
           LexArrayItem, LexInteger, LexObject, LexObjectProperty, LexRecord, LexString, LexStringFormat,

     

       5
       5
       -
           LexUserType, LexXrpcBody, LexXrpcBodySchema, LexXrpcError, LexXrpcProcedure, LexXrpcQuery,

     

       6
       6
       -
           LexXrpcSubscription, LexXrpcSubscriptionMessageSchema,

     

       7
       7
       -
       };

     

       8
       8
       -
       use heck::{ToPascalCase, ToSnakeCase};

     

       3
       3
       +
       use crate::lexicon::{LexArrayItem, LexUserType};

     

       9
       4
        
       use proc_macro2::TokenStream;

     

       10
       5
        
       use quote::quote;

     

       11
       6
        
       

     

       12
       12
       -
       /// Convert a value string to a valid Rust variant name

     

       13
       13
       -
       fn value_to_variant_name(value: &str) -> String {

     

       14
       14
       -
           // Remove leading special chars and convert to pascal case

     

       15
       15
       -
           let clean = value.trim_start_matches(|c: char| !c.is_alphanumeric());

     

       16
       16
       -
           let variant = clean.replace('-', "_").to_pascal_case();

     

       17
       17
       -
       

     

       18
       18
       -
           // Prefix with underscore if starts with digit

     

       19
       19
       -
           if variant.chars().next().map_or(false, |c| c.is_ascii_digit()) {

     

       20
       20
       -
               format!("_{}", variant)

     

       21
       21
       -
           } else if variant.is_empty() {

     

       22
       22
       -
               "Unknown".to_string()

     

       23
       23
       -
           } else {

     

       24
       24
       -
               variant

     

       25
       25
       -
           }

     

       26
       26
       -
       }

     

       27
       27
       -
       

     

       28
       28
       -
       /// Sanitize a string to be safe for identifiers and filenames

     

       29
       29
       -
       fn sanitize_name(s: &str) -> String {

     

       30
       30
       -
           if s.is_empty() {

     

       31
       31
       -
               return "unknown".to_string();

     

       32
       32
       -
           }

     

       33
       33
       -
       

     

       34
       34
       -
           // Replace invalid characters with underscores

     

       35
       35
       -
           let mut sanitized: String = s

     

       36
       36
       -
               .chars()

     

       37
       37
       -
               .map(|c| {

     

       38
       38
       -
                   if c.is_alphanumeric() || c == '_' {

     

       39
       39
       -
                       c

     

       40
       40
       -
                   } else {

     

       41
       41
       -
                       '_'

     

       42
       42
       -
                   }

     

       43
       43
       -
               })

     

       44
       44
       -
               .collect();

     

       45
       45
       -
       

     

       46
       46
       -
           // Ensure it doesn't start with a digit

     

       47
       47
       -
           if sanitized

     

       48
       48
       -
               .chars()

     

       49
       49
       -
               .next()

     

       50
       50
       -
               .map_or(false, |c| c.is_ascii_digit())

     

       51
       51
       -
           {

     

       52
       52
       -
               sanitized = format!("_{}", sanitized);

     

       53
       53
       -
           }

     

       54
       54
       -
       

     

       55
       55
       -
           sanitized

     

       56
       56
       -
       }

     

       57
       57
       -
       

     

       58
       58
       -
       /// Create an identifier, using raw identifier if necessary for keywords

     

       59
       59
       -
       fn make_ident(s: &str) -> syn::Ident {

     

       60
       60
       -
           if s.is_empty() {

     

       61
       61
       -
               eprintln!("Warning: Empty identifier encountered, using 'unknown' as fallback");

     

       62
       62
       -
               return syn::Ident::new("unknown", proc_macro2::Span::call_site());

     

       63
       63
       -
           }

     

       64
       64
       -
       

     

       65
       65
       -
           let sanitized = sanitize_name(s);

     

       66
       66
       -
       

     

       67
       67
       -
           // Try to parse as ident, fall back to raw ident if needed

     

       68
       68
       -
           syn::parse_str::<syn::Ident>(&sanitized).unwrap_or_else(|_| {

     

       69
       69
       -
               eprintln!(

     

       70
       70
       -
                   "Warning: Invalid identifier '{}' sanitized to '{}'",

     

       71
       71
       -
                   s, sanitized

     

       72
       72
       -
               );

     

       73
       73
       -
               syn::Ident::new_raw(&sanitized, proc_macro2::Span::call_site())

     

       74
       74
       -
           })

     

       75
       75
       -
       }

     

       7
       7
       +
       mod utils;

     

       8
       8
       +
       mod names;

     

       9
       9
       +
       mod lifetime;

     

       10
       10
       +
       mod types;

     

       11
       11
       +
       mod structs;

     

       12
       12
       +
       mod xrpc;

     

       13
       13
       +
       mod output;

     

       76
       14
        
       

     

       77
       15
        
       /// Code generator for lexicon types

     

       78
       16
        
       pub struct CodeGenerator<'c> {

     
···

       93
       31
        
               }

     

       94
       32
        
           }

     

       95
       33
        
       

     

       34
       34
       +
           /// Generate doc comment from optional description (wrapper for utils function)

     

       35
       35
       +
           fn generate_doc_comment(&self, desc: Option<&jacquard_common::CowStr>) -> TokenStream {

     

       36
       36
       +
               utils::generate_doc_comment(desc)

     

       37
       37
       +
           }

     

       38
       38
       +
       

     

       96
       39
        
           /// Generate code for a lexicon def

     

       97
       40
        
           pub fn generate_def(

     

       98
       41
        
               &self,

     
···

       147
       90
        
                       // Top-level array becomes type alias to Vec<ItemType>

     

       148
       91
        
                       let type_name = self.def_to_type_name(nsid, def_name);

     

       149
       92
        
                       let ident = syn::Ident::new(&type_name, proc_macro2::Span::call_site());

     

       150
       150
       -
                       let item_type = self.array_item_to_rust_type(nsid, &array.items)?;

     

       151
       93
        
                       let doc = self.generate_doc_comment(array.description.as_ref());

     

       152
       94
        
                       let needs_lifetime = self.array_item_needs_lifetime(&array.items);

     

       153
       153
       -
                       if needs_lifetime {

     

       154
       154
       -
                           Ok(quote! {

     

       155
       155
       -
                               #doc

     

       156
       156
       -
                               pub type #ident<'a> = Vec<#item_type>;

     

       157
       157
       -
                           })

     

       95
       95
       +
       

     

       96
       96
       +
                       // Check if items are a union - if so, generate the union enum first

     

       97
       97
       +
                       if let LexArrayItem::Union(union) = &array.items {

     

       98
       98
       +
                           let union_name = format!("{}Item", type_name);

     

       99
       99
       +
                           let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       100
       100
       +
                           let union_def = self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       101
       101
       +
       

     

       102
       102
       +
                           let union_ident = syn::Ident::new(&union_name, proc_macro2::Span::call_site());

     

       103
       103
       +
                           if needs_lifetime {

     

       104
       104
       +
                               Ok(quote! {

     

       105
       105
       +
                                   #union_def

     

       106
       106
       +
       

     

       107
       107
       +
                                   #doc

     

       108
       108
       +
                                   pub type #ident<'a> = Vec<#union_ident<'a>>;

     

       109
       109
       +
                               })

     

       110
       110
       +
                           } else {

     

       111
       111
       +
                               Ok(quote! {

     

       112
       112
       +
                                   #union_def

     

       113
       113
       +
       

     

       114
       114
       +
                                   #doc

     

       115
       115
       +
                                   pub type #ident = Vec<#union_ident>;

     

       116
       116
       +
                               })

     

       117
       117
       +
                           }

     

       158
       118
        
                       } else {

     

       159
       159
       -
                           Ok(quote! {

     

       160
       160
       -
                               #doc

     

       161
       161
       -
                               pub type #ident = Vec<#item_type>;

     

       162
       162
       -
                           })

     

       119
       119
       +
                           // Regular array item type

     

       120
       120
       +
                           let item_type = self.array_item_to_rust_type(nsid, &array.items)?;

     

       121
       121
       +
                           if needs_lifetime {

     

       122
       122
       +
                               Ok(quote! {

     

       123
       123
       +
                                   #doc

     

       124
       124
       +
                                   pub type #ident<'a> = Vec<#item_type>;

     

       125
       125
       +
                               })

     

       126
       126
       +
                           } else {

     

       127
       127
       +
                               Ok(quote! {

     

       128
       128
       +
                                   #doc

     

       129
       129
       +
                                   pub type #ident = Vec<#item_type>;

     

       130
       130
       +
                               })

     

       131
       131
       +
                           }

     

       163
       132
        
                       }

     

       164
       133
        
                   }

     

       165
       134
        
                   LexUserType::Boolean(_)

     
···

       200
       169
        
                   LexUserType::XrpcSubscription(sub) => self.generate_subscription(nsid, def_name, sub),

     

       201
       170
        
               }

     

       202
       171
        
           }

     

       203
       203
       -
       

     

       204
       204
       -
           /// Generate a record type

     

       205
       205
       -
           fn generate_record(

     

       206
       206
       -
               &self,

     

       207
       207
       -
               nsid: &str,

     

       208
       208
       -
               def_name: &str,

     

       209
       209
       -
               record: &LexRecord<'static>,

     

       210
       210
       -
           ) -> Result<TokenStream> {

     

       211
       211
       -
               match &record.record {

     

       212
       212
       -
                   crate::lexicon::LexRecordRecord::Object(obj) => {

     

       213
       213
       -
                       let type_name = self.def_to_type_name(nsid, def_name);

     

       214
       214
       -
                       let ident = syn::Ident::new(&type_name, proc_macro2::Span::call_site());

     

       215
       215
       -
       

     

       216
       216
       -
                       // Generate main struct fields

     

       217
       217
       -
                       let fields = self.generate_object_fields(nsid, &type_name, obj, false)?;

     

       218
       218
       -
                       let doc = self.generate_doc_comment(record.description.as_ref());

     

       219
       219
       -
       

     

       220
       220
       -
                       // Records always get a lifetime since they have the #[lexicon] attribute

     

       221
       221
       -
                       // which adds extra_data: BTreeMap<..., Data<'a>>

     

       222
       222
       -
                       let struct_def = quote! {

     

       223
       223
       -
                           #doc

     

       224
       224
       -
                           #[jacquard_derive::lexicon]

     

       225
       225
       -
                           #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       226
       226
       -
                           #[serde(rename_all = "camelCase")]

     

       227
       227
       -
                           pub struct #ident<'a> {

     

       228
       228
       -
                               #fields

     

       229
       229
       -
                           }

     

       230
       230
       -
                       };

     

       231
       231
       -
       

     

       232
       232
       -
                       // Generate union types and nested object types for this record

     

       233
       233
       -
                       let mut unions = Vec::new();

     

       234
       234
       -
                       for (field_name, field_type) in &obj.properties {

     

       235
       235
       -
                           match field_type {

     

       236
       236
       -
                               LexObjectProperty::Union(union) => {

     

       237
       237
       -
                                   let union_name =

     

       238
       238
       -
                                       format!("{}Record{}", type_name, field_name.to_pascal_case());

     

       239
       239
       -
                                   // Clone refs to avoid lifetime issues

     

       240
       240
       -
                                   let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       241
       241
       -
                                   let union_def =

     

       242
       242
       -
                                       self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       243
       243
       -
                                   unions.push(union_def);

     

       244
       244
       -
                               }

     

       245
       245
       -
                               LexObjectProperty::Object(nested_obj) => {

     

       246
       246
       -
                                   let object_name =

     

       247
       247
       -
                                       format!("{}Record{}", type_name, field_name.to_pascal_case());

     

       248
       248
       -
                                   let obj_def = self.generate_object(nsid, &object_name, nested_obj)?;

     

       249
       249
       -
                                   unions.push(obj_def);

     

       250
       250
       -
                               }

     

       251
       251
       -
                               _ => {}

     

       252
       252
       -
                           }

     

       253
       253
       -
                       }

     

       254
       254
       -
       

     

       255
       255
       -
                       // Generate Collection trait impl

     

       256
       256
       -
                       let collection_impl = quote! {

     

       257
       257
       -
                           impl jacquard_common::types::collection::Collection for #ident<'_> {

     

       258
       258
       -
                               const NSID: &'static str = #nsid;

     

       259
       259
       -
                           }

     

       260
       260
       -
                       };

     

       261
       261
       -
       

     

       262
       262
       -
                       // Generate IntoStatic impl

     

       263
       263
       -
                       // let field_names: Vec<&str> = obj.properties.keys().map(|k| k.as_str()).collect();

     

       264
       264
       -
                       // let into_static_impl =

     

       265
       265
       -
                       //     self.generate_into_static_for_struct(&type_name, &field_names, true, true);

     

       266
       266
       -
       

     

       267
       267
       -
                       Ok(quote! {

     

       268
       268
       -
                           #struct_def

     

       269
       269
       -
                           #(#unions)*

     

       270
       270
       -
                           #collection_impl

     

       271
       271
       -
                           //#into_static_impl

     

       272
       272
       -
                       })

     

       273
       273
       -
                   }

     

       274
       274
       -
               }

     

       275
       275
       -
           }

     

       276
       276
       -
       

     

       277
       277
       -
           /// Generate an object type

     

       278
       278
       -
           fn generate_object(

     

       279
       279
       -
               &self,

     

       280
       280
       -
               nsid: &str,

     

       281
       281
       -
               def_name: &str,

     

       282
       282
       -
               obj: &LexObject<'static>,

     

       283
       283
       -
           ) -> Result<TokenStream> {

     

       284
       284
       -
               let type_name = self.def_to_type_name(nsid, def_name);

     

       285
       285
       -
               let ident = syn::Ident::new(&type_name, proc_macro2::Span::call_site());

     

       286
       286
       -
       

     

       287
       287
       -
               let fields = self.generate_object_fields(nsid, &type_name, obj, false)?;

     

       288
       288
       -
               let doc = self.generate_doc_comment(obj.description.as_ref());

     

       289
       289
       -
       

     

       290
       290
       -
               // Objects always get a lifetime since they have the #[lexicon] attribute

     

       291
       291
       -
               // which adds extra_data: BTreeMap<..., Data<'a>>

     

       292
       292
       -
               let struct_def = quote! {

     

       293
       293
       -
                   #doc

     

       294
       294
       -
                   #[jacquard_derive::lexicon]

     

       295
       295
       -
                   #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       296
       296
       -
                   #[serde(rename_all = "camelCase")]

     

       297
       297
       -
                   pub struct #ident<'a> {

     

       298
       298
       -
                       #fields

     

       299
       299
       -
                   }

     

       300
       300
       -
               };

     

       301
       301
       -
       

     

       302
       302
       -
               // Generate union types and nested object types for this object

     

       303
       303
       -
               let mut unions = Vec::new();

     

       304
       304
       -
               for (field_name, field_type) in &obj.properties {

     

       305
       305
       -
                   match field_type {

     

       306
       306
       -
                       LexObjectProperty::Union(union) => {

     

       307
       307
       -
                           let union_name = format!("{}Record{}", type_name, field_name.to_pascal_case());

     

       308
       308
       -
                           let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       309
       309
       -
                           let union_def =

     

       310
       310
       -
                               self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       311
       311
       -
                           unions.push(union_def);

     

       312
       312
       -
                       }

     

       313
       313
       -
                       LexObjectProperty::Object(nested_obj) => {

     

       314
       314
       -
                           let object_name = format!("{}Record{}", type_name, field_name.to_pascal_case());

     

       315
       315
       -
                           let obj_def = self.generate_object(nsid, &object_name, nested_obj)?;

     

       316
       316
       -
                           unions.push(obj_def);

     

       317
       317
       -
                       }

     

       318
       318
       -
                       _ => {}

     

       319
       319
       -
                   }

     

       320
       320
       -
               }

     

       321
       321
       -
       

     

       322
       322
       -
               // Generate IntoStatic impl

     

       323
       323
       -
               // let field_names: Vec<&str> = obj.properties.keys().map(|k| k.as_str()).collect();

     

       324
       324
       -
               // let into_static_impl =

     

       325
       325
       -
               //     self.generate_into_static_for_struct(&type_name, &field_names, true, true);

     

       326
       326
       -
       

     

       327
       327
       -
               Ok(quote! {

     

       328
       328
       -
                   #struct_def

     

       329
       329
       -
                   #(#unions)*

     

       330
       330
       -
                   //#into_static_impl

     

       331
       331
       -
               })

     

       332
       332
       -
           }

     

       333
       333
       -
       

     

       334
       334
       -
           /// Generate fields for an object

     

       335
       335
       -
           fn generate_object_fields(

     

       336
       336
       -
               &self,

     

       337
       337
       -
               nsid: &str,

     

       338
       338
       -
               parent_type_name: &str,

     

       339
       339
       -
               obj: &LexObject<'static>,

     

       340
       340
       -
               is_builder: bool,

     

       341
       341
       -
           ) -> Result<TokenStream> {

     

       342
       342
       -
               let required = obj.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]);

     

       343
       343
       -
       

     

       344
       344
       -
               let mut fields = Vec::new();

     

       345
       345
       -
               for (field_name, field_type) in &obj.properties {

     

       346
       346
       -
                   let is_required = required.contains(field_name);

     

       347
       347
       -
                   let field_tokens = self.generate_field(

     

       348
       348
       -
                       nsid,

     

       349
       349
       -
                       parent_type_name,

     

       350
       350
       -
                       field_name,

     

       351
       351
       -
                       field_type,

     

       352
       352
       -
                       is_required,

     

       353
       353
       -
                       is_builder,

     

       354
       354
       -
                   )?;

     

       355
       355
       -
                   fields.push(field_tokens);

     

       356
       356
       -
               }

     

       357
       357
       -
       

     

       358
       358
       -
               Ok(quote! { #(#fields)* })

     

       359
       359
       -
           }

     

       360
       360
       -
       

     

       361
       361
       -
           /// Generate a single field

     

       362
       362
       -
           fn generate_field(

     

       363
       363
       -
               &self,

     

       364
       364
       -
               nsid: &str,

     

       365
       365
       -
               parent_type_name: &str,

     

       366
       366
       -
               field_name: &str,

     

       367
       367
       -
               field_type: &LexObjectProperty<'static>,

     

       368
       368
       -
               is_required: bool,

     

       369
       369
       -
               is_builder: bool,

     

       370
       370
       -
           ) -> Result<TokenStream> {

     

       371
       371
       -
               if field_name.is_empty() {

     

       372
       372
       -
                   eprintln!(

     

       373
       373
       -
                       "Warning: Empty field name in lexicon '{}' type '{}', using 'unknown' as fallback",

     

       374
       374
       -
                       nsid, parent_type_name

     

       375
       375
       -
                   );

     

       376
       376
       -
               }

     

       377
       377
       -
               let field_ident = make_ident(&field_name.to_snake_case());

     

       378
       378
       -
       

     

       379
       379
       -
               let rust_type =

     

       380
       380
       -
                   self.property_to_rust_type(nsid, parent_type_name, field_name, field_type)?;

     

       381
       381
       -
               let needs_lifetime = self.property_needs_lifetime(field_type);

     

       382
       382
       -
       

     

       383
       383
       -
               // Check if this is a CowStr field for builder(into) attribute

     

       384
       384
       -
               let is_cowstr = matches!(field_type, LexObjectProperty::String(s) if s.format.is_none());

     

       385
       385
       -
       

     

       386
       386
       -
               let rust_type = if is_required {

     

       387
       387
       -
                   rust_type

     

       388
       388
       -
               } else {

     

       389
       389
       -
                   quote! { std::option::Option<#rust_type> }

     

       390
       390
       -
               };

     

       391
       391
       -
       

     

       392
       392
       -
               // Extract description from field type

     

       393
       393
       -
               let description = match field_type {

     

       394
       394
       -
                   LexObjectProperty::Ref(r) => r.description.as_ref(),

     

       395
       395
       -
                   LexObjectProperty::Union(u) => u.description.as_ref(),

     

       396
       396
       -
                   LexObjectProperty::Bytes(b) => b.description.as_ref(),

     

       397
       397
       -
                   LexObjectProperty::CidLink(c) => c.description.as_ref(),

     

       398
       398
       -
                   LexObjectProperty::Array(a) => a.description.as_ref(),

     

       399
       399
       -
                   LexObjectProperty::Blob(b) => b.description.as_ref(),

     

       400
       400
       -
                   LexObjectProperty::Object(o) => o.description.as_ref(),

     

       401
       401
       -
                   LexObjectProperty::Boolean(b) => b.description.as_ref(),

     

       402
       402
       -
                   LexObjectProperty::Integer(i) => i.description.as_ref(),

     

       403
       403
       -
                   LexObjectProperty::String(s) => s.description.as_ref(),

     

       404
       404
       -
                   LexObjectProperty::Unknown(u) => u.description.as_ref(),

     

       405
       405
       -
               };

     

       406
       406
       -
               let doc = self.generate_doc_comment(description);

     

       407
       407
       -
       

     

       408
       408
       -
               let mut attrs = Vec::new();

     

       409
       409
       -
       

     

       410
       410
       -
               if !is_required {

     

       411
       411
       -
                   attrs.push(quote! { #[serde(skip_serializing_if = "std::option::Option::is_none")] });

     

       412
       412
       -
               }

     

       413
       413
       -
       

     

       414
       414
       -
               // Add serde(borrow) to all fields with lifetimes

     

       415
       415
       -
               if needs_lifetime {

     

       416
       416
       -
                   attrs.push(quote! { #[serde(borrow)] });

     

       417
       417
       -
               }

     

       418
       418
       -
       

     

       419
       419
       -
               // Add builder(into) for CowStr fields to allow String, &str, etc., but only for builder structs

     

       420
       420
       -
               if is_builder && is_cowstr {

     

       421
       421
       -
                   attrs.push(quote! { #[builder(into)] });

     

       422
       422
       -
               }

     

       423
       423
       -
       

     

       424
       424
       -
               Ok(quote! {

     

       425
       425
       -
                   #doc

     

       426
       426
       -
                   #(#attrs)*

     

       427
       427
       -
                   pub #field_ident: #rust_type,

     

       428
       428
       -
               })

     

       429
       429
       -
           }

     

       430
       430
       -
       

     

       431
       431
       -
           /// Check if a property type needs a lifetime parameter

     

       432
       432
       -
           fn property_needs_lifetime(&self, prop: &LexObjectProperty<'static>) -> bool {

     

       433
       433
       -
               match prop {

     

       434
       434
       -
                   LexObjectProperty::Boolean(_) | LexObjectProperty::Integer(_) => false,

     

       435
       435
       -
                   LexObjectProperty::String(s) => self.string_needs_lifetime(s),

     

       436
       436
       -
                   LexObjectProperty::Bytes(_) => false, // Bytes is owned

     

       437
       437
       -
                   LexObjectProperty::CidLink(_)

     

       438
       438
       -
                   | LexObjectProperty::Blob(_)

     

       439
       439
       -
                   | LexObjectProperty::Unknown(_) => true,

     

       440
       440
       -
                   LexObjectProperty::Array(array) => self.array_item_needs_lifetime(&array.items),

     

       441
       441
       -
                   LexObjectProperty::Object(_) => true, // Nested objects have lifetimes

     

       442
       442
       -
                   LexObjectProperty::Ref(ref_type) => {

     

       443
       443
       -
                       // Check if the ref target actually needs a lifetime

     

       444
       444
       -
                       self.ref_needs_lifetime(&ref_type.r#ref)

     

       445
       445
       -
                   }

     

       446
       446
       -
                   LexObjectProperty::Union(_) => true, // Unions generally have lifetimes

     

       447
       447
       -
               }

     

       448
       448
       -
           }

     

       449
       449
       -
       

     

       450
       450
       -
           /// Check if an array item type needs a lifetime parameter

     

       451
       451
       -
           fn array_item_needs_lifetime(&self, item: &LexArrayItem) -> bool {

     

       452
       452
       -
               match item {

     

       453
       453
       -
                   LexArrayItem::Boolean(_) | LexArrayItem::Integer(_) => false,

     

       454
       454
       -
                   LexArrayItem::String(s) => self.string_needs_lifetime(s),

     

       455
       455
       -
                   LexArrayItem::Bytes(_) => false,

     

       456
       456
       -
                   LexArrayItem::CidLink(_) | LexArrayItem::Blob(_) | LexArrayItem::Unknown(_) => true,

     

       457
       457
       -
                   LexArrayItem::Object(_) => true, // Nested objects have lifetimes

     

       458
       458
       -
                   LexArrayItem::Ref(ref_type) => self.ref_needs_lifetime(&ref_type.r#ref),

     

       459
       459
       -
                   LexArrayItem::Union(_) => true,

     

       460
       460
       -
               }

     

       461
       461
       -
           }

     

       462
       462
       -
       

     

       463
       463
       -
           /// Check if a string type needs a lifetime parameter

     

       464
       464
       -
           fn string_needs_lifetime(&self, s: &LexString) -> bool {

     

       465
       465
       -
               match s.format {

     

       466
       466
       -
                   Some(LexStringFormat::Datetime)

     

       467
       467
       -
                   | Some(LexStringFormat::Language)

     

       468
       468
       -
                   | Some(LexStringFormat::Tid) => false,

     

       469
       469
       -
                   _ => true, // Most string types borrow

     

       470
       470
       -
               }

     

       471
       471
       -
           }

     

       472
       472
       -
       

     

       473
       473
       -
           /// Check if a ref needs a lifetime parameter

     

       474
       474
       -
           fn ref_needs_lifetime(&self, ref_str: &str) -> bool {

     

       475
       475
       -
               // Try to resolve the ref

     

       476
       476
       -
               if let Some((_doc, def)) = self.corpus.resolve_ref(ref_str) {

     

       477
       477
       -
                   self.def_needs_lifetime(def)

     

       478
       478
       -
               } else {

     

       479
       479
       -
                   // If we can't resolve it, assume it needs a lifetime (safe default)

     

       480
       480
       -
                   true

     

       481
       481
       -
               }

     

       482
       482
       -
           }

     

       483
       483
       -
       

     

       484
       484
       -
           /// Check if a lexicon def needs a lifetime parameter

     

       485
       485
       -
           fn def_needs_lifetime(&self, def: &LexUserType<'static>) -> bool {

     

       486
       486
       -
               match def {

     

       487
       487
       -
                   // Records and Objects always have lifetimes now since they get #[lexicon] attribute

     

       488
       488
       -
                   LexUserType::Record(_) => true,

     

       489
       489
       -
                   LexUserType::Object(_) => true,

     

       490
       490
       -
                   LexUserType::Token(_) => false,

     

       491
       491
       -
                   LexUserType::String(s) => {

     

       492
       492
       -
                       // Check if it's a known values enum or a regular string

     

       493
       493
       -
                       if s.known_values.is_some() {

     

       494
       494
       -
                           // Known values enums have Other(CowStr<'a>) variant

     

       495
       495
       -
                           true

     

       496
       496
       -
                       } else {

     

       497
       497
       -
                           self.string_needs_lifetime(s)

     

       498
       498
       -
                       }

     

       499
       499
       -
                   }

     

       500
       500
       -
                   LexUserType::Integer(_) => false,

     

       501
       501
       -
                   LexUserType::Boolean(_) => false,

     

       502
       502
       -
                   LexUserType::Bytes(_) => false,

     

       503
       503
       -
                   LexUserType::CidLink(_) | LexUserType::Blob(_) | LexUserType::Unknown(_) => true,

     

       504
       504
       -
                   LexUserType::Array(array) => self.array_item_needs_lifetime(&array.items),

     

       505
       505
       -
                   LexUserType::XrpcQuery(_)

     

       506
       506
       -
                   | LexUserType::XrpcProcedure(_)

     

       507
       507
       -
                   | LexUserType::XrpcSubscription(_) => {

     

       508
       508
       -
                       // XRPC types generate multiple structs, not a single type we can reference

     

       509
       509
       -
                       // Shouldn't be referenced directly

     

       510
       510
       -
                       true

     

       511
       511
       -
                   }

     

       512
       512
       -
               }

     

       513
       513
       -
           }

     

       514
       514
       -
       

     

       515
       515
       -
           /// Check if xrpc params need a lifetime parameter

     

       516
       516
       -
           fn params_need_lifetime(&self, params: &crate::lexicon::LexXrpcParameters<'static>) -> bool {

     

       517
       517
       -
               params.properties.values().any(|prop| {

     

       518
       518
       -
                   use crate::lexicon::LexXrpcParametersProperty;

     

       519
       519
       -
                   match prop {

     

       520
       520
       -
                       LexXrpcParametersProperty::Boolean(_) | LexXrpcParametersProperty::Integer(_) => {

     

       521
       521
       -
                           false

     

       522
       522
       -
                       }

     

       523
       523
       -
                       LexXrpcParametersProperty::String(s) => self.string_needs_lifetime(s),

     

       524
       524
       -
                       LexXrpcParametersProperty::Unknown(_) => true,

     

       525
       525
       -
                       LexXrpcParametersProperty::Array(arr) => {

     

       526
       526
       -
                           use crate::lexicon::LexPrimitiveArrayItem;

     

       527
       527
       -
                           match &arr.items {

     

       528
       528
       -
                               LexPrimitiveArrayItem::Boolean(_) | LexPrimitiveArrayItem::Integer(_) => {

     

       529
       529
       -
                                   false

     

       530
       530
       -
                               }

     

       531
       531
       -
                               LexPrimitiveArrayItem::String(s) => self.string_needs_lifetime(s),

     

       532
       532
       -
                               LexPrimitiveArrayItem::Unknown(_) => true,

     

       533
       533
       -
                           }

     

       534
       534
       -
                       }

     

       535
       535
       -
                   }

     

       536
       536
       -
               })

     

       537
       537
       -
           }

     

       538
       538
       -
       

     

       539
       539
       -
           /// Convert a property type to Rust type

     

       540
       540
       -
           fn property_to_rust_type(

     

       541
       541
       -
               &self,

     

       542
       542
       -
               nsid: &str,

     

       543
       543
       -
               parent_type_name: &str,

     

       544
       544
       -
               field_name: &str,

     

       545
       545
       -
               prop: &LexObjectProperty<'static>,

     

       546
       546
       -
           ) -> Result<TokenStream> {

     

       547
       547
       -
               match prop {

     

       548
       548
       -
                   LexObjectProperty::Boolean(_) => Ok(quote! { bool }),

     

       549
       549
       -
                   LexObjectProperty::Integer(_) => Ok(quote! { i64 }),

     

       550
       550
       -
                   LexObjectProperty::String(s) => Ok(self.string_to_rust_type(s)),

     

       551
       551
       -
                   LexObjectProperty::Bytes(_) => Ok(quote! { bytes::Bytes }),

     

       552
       552
       -
                   LexObjectProperty::CidLink(_) => {

     

       553
       553
       -
                       Ok(quote! { jacquard_common::types::cid::CidLink<'a> })

     

       554
       554
       -
                   }

     

       555
       555
       -
                   LexObjectProperty::Blob(_) => Ok(quote! { jacquard_common::types::blob::Blob<'a> }),

     

       556
       556
       -
                   LexObjectProperty::Unknown(_) => Ok(quote! { jacquard_common::types::value::Data<'a> }),

     

       557
       557
       -
                   LexObjectProperty::Array(array) => {

     

       558
       558
       -
                       let item_type = self.array_item_to_rust_type(nsid, &array.items)?;

     

       559
       559
       -
                       Ok(quote! { Vec<#item_type> })

     

       560
       560
       -
                   }

     

       561
       561
       -
                   LexObjectProperty::Object(_object) => {

     

       562
       562
       -
                       // Generate unique nested object type name: StatusView + metadata -> StatusViewRecordMetadata

     

       563
       563
       -
                       let object_name =

     

       564
       564
       -
                           format!("{}Record{}", parent_type_name, field_name.to_pascal_case());

     

       565
       565
       -
                       let object_ident = syn::Ident::new(&object_name, proc_macro2::Span::call_site());

     

       566
       566
       -
                       Ok(quote! { #object_ident<'a> })

     

       567
       567
       -
                   }

     

       568
       568
       -
                   LexObjectProperty::Ref(ref_type) => {

     

       569
       569
       -
                       // Handle local refs (starting with #) by prepending the current NSID

     

       570
       570
       -
                       let ref_str = if ref_type.r#ref.starts_with('#') {

     

       571
       571
       -
                           format!("{}{}", nsid, ref_type.r#ref)

     

       572
       572
       -
                       } else {

     

       573
       573
       -
                           ref_type.r#ref.to_string()

     

       574
       574
       -
                       };

     

       575
       575
       -
                       self.ref_to_rust_type(&ref_str)

     

       576
       576
       -
                   }

     

       577
       577
       -
                   LexObjectProperty::Union(_union) => {

     

       578
       578
       -
                       // Generate unique union type name: StatusView + embed -> StatusViewRecordEmbed

     

       579
       579
       -
                       let union_name =

     

       580
       580
       -
                           format!("{}Record{}", parent_type_name, field_name.to_pascal_case());

     

       581
       581
       -
                       let union_ident = syn::Ident::new(&union_name, proc_macro2::Span::call_site());

     

       582
       582
       -
                       Ok(quote! { #union_ident<'a> })

     

       583
       583
       -
                   }

     

       584
       584
       -
               }

     

       585
       585
       -
           }

     

       586
       586
       -
       

     

       587
       587
       -
           /// Convert array item to Rust type

     

       588
       588
       -
           fn array_item_to_rust_type(&self, nsid: &str, item: &LexArrayItem) -> Result<TokenStream> {

     

       589
       589
       -
               match item {

     

       590
       590
       -
                   LexArrayItem::Boolean(_) => Ok(quote! { bool }),

     

       591
       591
       -
                   LexArrayItem::Integer(_) => Ok(quote! { i64 }),

     

       592
       592
       -
                   LexArrayItem::String(s) => Ok(self.string_to_rust_type(s)),

     

       593
       593
       -
                   LexArrayItem::Bytes(_) => Ok(quote! { bytes::Bytes }),

     

       594
       594
       -
                   LexArrayItem::CidLink(_) => Ok(quote! { jacquard_common::types::cid::CidLink<'a> }),

     

       595
       595
       -
                   LexArrayItem::Blob(_) => Ok(quote! { jacquard_common::types::blob::Blob<'a> }),

     

       596
       596
       -
                   LexArrayItem::Unknown(_) => Ok(quote! { jacquard_common::types::value::Data<'a> }),

     

       597
       597
       -
                   LexArrayItem::Object(_) => {

     

       598
       598
       -
                       // For inline objects in arrays, use Data since we can't generate a unique type name

     

       599
       599
       -
                       Ok(quote! { jacquard_common::types::value::Data<'a> })

     

       600
       600
       -
                   }

     

       601
       601
       -
                   LexArrayItem::Ref(ref_type) => {

     

       602
       602
       -
                       // Handle local refs (starting with #) by prepending the current NSID

     

       603
       603
       -
                       let ref_str = if ref_type.r#ref.starts_with('#') {

     

       604
       604
       -
                           format!("{}{}", nsid, ref_type.r#ref)

     

       605
       605
       -
                       } else {

     

       606
       606
       -
                           ref_type.r#ref.to_string()

     

       607
       607
       -
                       };

     

       608
       608
       -
                       self.ref_to_rust_type(&ref_str)

     

       609
       609
       -
                   }

     

       610
       610
       -
                   LexArrayItem::Union(_) => {

     

       611
       611
       -
                       // For now, use Data

     

       612
       612
       -
                       Ok(quote! { jacquard_common::types::value::Data<'a> })

     

       613
       613
       -
                   }

     

       614
       614
       -
               }

     

       615
       615
       -
           }

     

       616
       616
       -
       

     

       617
       617
       -
           /// Convert string type to Rust type

     

       618
       618
       -
           fn string_to_rust_type(&self, s: &LexString) -> TokenStream {

     

       619
       619
       -
               match s.format {

     

       620
       620
       -
                   Some(LexStringFormat::Datetime) => {

     

       621
       621
       -
                       quote! { jacquard_common::types::string::Datetime }

     

       622
       622
       -
                   }

     

       623
       623
       -
                   Some(LexStringFormat::Did) => quote! { jacquard_common::types::string::Did<'a> },

     

       624
       624
       -
                   Some(LexStringFormat::Handle) => quote! { jacquard_common::types::string::Handle<'a> },

     

       625
       625
       -
                   Some(LexStringFormat::AtIdentifier) => {

     

       626
       626
       -
                       quote! { jacquard_common::types::ident::AtIdentifier<'a> }

     

       627
       627
       -
                   }

     

       628
       628
       -
                   Some(LexStringFormat::Nsid) => quote! { jacquard_common::types::string::Nsid<'a> },

     

       629
       629
       -
                   Some(LexStringFormat::AtUri) => quote! { jacquard_common::types::string::AtUri<'a> },

     

       630
       630
       -
                   Some(LexStringFormat::Uri) => quote! { jacquard_common::types::string::Uri<'a> },

     

       631
       631
       -
                   Some(LexStringFormat::Cid) => quote! { jacquard_common::types::string::Cid<'a> },

     

       632
       632
       -
                   Some(LexStringFormat::Language) => {

     

       633
       633
       -
                       quote! { jacquard_common::types::string::Language }

     

       634
       634
       -
                   }

     

       635
       635
       -
                   Some(LexStringFormat::Tid) => quote! { jacquard_common::types::string::Tid },

     

       636
       636
       -
                   Some(LexStringFormat::RecordKey) => {

     

       637
       637
       -
                       quote! { jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>> }

     

       638
       638
       -
                   }

     

       639
       639
       -
                   _ => quote! { jacquard_common::CowStr<'a> },

     

       640
       640
       -
               }

     

       641
       641
       -
           }

     

       642
       642
       -
       

     

       643
       643
       -
           /// Convert ref to Rust type path

     

       644
       644
       -
           fn ref_to_rust_type(&self, ref_str: &str) -> Result<TokenStream> {

     

       645
       645
       -
               // Parse NSID and fragment

     

       646
       646
       -
               let (ref_nsid, ref_def) = if let Some((nsid, fragment)) = ref_str.split_once('#') {

     

       647
       647
       -
                   (nsid, fragment)

     

       648
       648
       -
               } else {

     

       649
       649
       -
                   (ref_str, "main")

     

       650
       650
       -
               };

     

       651
       651
       -
       

     

       652
       652
       -
               // Check if ref exists

     

       653
       653
       -
               if !self.corpus.ref_exists(ref_str) {

     

       654
       654
       -
                   // Fallback to Data

     

       655
       655
       -
                   return Ok(quote! { jacquard_common::types::value::Data<'a> });

     

       656
       656
       -
               }

     

       657
       657
       -
       

     

       658
       658
       -
               // Convert NSID to module path

     

       659
       659
       -
               // com.atproto.repo.strongRef -> com_atproto::repo::strong_ref::StrongRef

     

       660
       660
       -
               // app.bsky.richtext.facet -> app_bsky::richtext::facet::Facet

     

       661
       661
       -
               // app.bsky.actor.defs#nux -> app_bsky::actor::Nux (defs go in parent module)

     

       662
       662
       -
               let parts: Vec<&str> = ref_nsid.split('.').collect();

     

       663
       663
       -
               let last_segment = parts.last().unwrap();

     

       664
       664
       -
       

     

       665
       665
       -
               let type_name = self.def_to_type_name(ref_nsid, ref_def);

     

       666
       666
       -
       

     

       667
       667
       -
               let path_str = if *last_segment == "defs" && parts.len() >= 3 {

     

       668
       668
       -
                   // defs types go in parent module

     

       669
       669
       -
                   let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1]));

     

       670
       670
       -
                   if parts.len() == 3 {

     

       671
       671
       -
                       // com.atproto.defs -> com_atproto::TypeName

     

       672
       672
       -
                       format!("{}::{}::{}", self.root_module, first_two, type_name)

     

       673
       673
       -
                   } else {

     

       674
       674
       -
                       // app.bsky.actor.defs -> app_bsky::actor::TypeName

     

       675
       675
       -
                       let middle: Vec<_> = parts[2..parts.len() - 1]

     

       676
       676
       -
                           .iter()

     

       677
       677
       -
                           .copied()

     

       678
       678
       -
                           .map(|s| sanitize_name(s))

     

       679
       679
       -
                           .collect();

     

       680
       680
       -
                       format!(

     

       681
       681
       -
                           "{}::{}::{}::{}",

     

       682
       682
       -
                           self.root_module,

     

       683
       683
       -
                           first_two,

     

       684
       684
       -
                           middle.join("::"),

     

       685
       685
       -
                           type_name

     

       686
       686
       -
                       )

     

       687
       687
       -
                   }

     

       688
       688
       -
               } else {

     

       689
       689
       -
                   // Regular types go in their own module file

     

       690
       690
       -
                   let (module_path, file_module) = if parts.len() >= 3 {

     

       691
       691
       -
                       // Join first two segments with underscore

     

       692
       692
       -
                       let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1]));

     

       693
       693
       -
                       let file_name = sanitize_name(last_segment).to_snake_case();

     

       694
       694
       -
       

     

       695
       695
       -
                       if parts.len() > 3 {

     

       696
       696
       -
                           // Middle segments form the module path

     

       697
       697
       -
                           let middle: Vec<_> = parts[2..parts.len() - 1]

     

       698
       698
       -
                               .iter()

     

       699
       699
       -
                               .copied()

     

       700
       700
       -
                               .map(|s| sanitize_name(s))

     

       701
       701
       -
                               .collect();

     

       702
       702
       -
                           let base_path = format!("{}::{}", first_two, middle.join("::"));

     

       703
       703
       -
                           (base_path, file_name)

     

       704
       704
       -
                       } else {

     

       705
       705
       -
                           // Only 3 parts: com.atproto.label -> com_atproto, file: label

     

       706
       706
       -
                           (first_two, file_name)

     

       707
       707
       -
                       }

     

       708
       708
       -
                   } else if parts.len() == 2 {

     

       709
       709
       -
                       // e.g., "com.example" -> "com_example", file: example

     

       710
       710
       -
                       let first = sanitize_name(parts[0]);

     

       711
       711
       -
                       let file_name = sanitize_name(parts[1]).to_snake_case();

     

       712
       712
       -
                       (first, file_name)

     

       713
       713
       -
                   } else {

     

       714
       714
       -
                       (parts[0].to_string(), "main".to_string())

     

       715
       715
       -
                   };

     

       716
       716
       -
       

     

       717
       717
       -
                   format!(

     

       718
       718
       -
                       "{}::{}::{}::{}",

     

       719
       719
       -
                       self.root_module, module_path, file_module, type_name

     

       720
       720
       -
                   )

     

       721
       721
       -
               };

     

       722
       722
       -
       

     

       723
       723
       -
               let path: syn::Path = syn::parse_str(&path_str).map_err(|e| CodegenError::Other {

     

       724
       724
       -
                   message: format!("Failed to parse path: {} {}", path_str, e),

     

       725
       725
       -
                   source: None,

     

       726
       726
       -
               })?;

     

       727
       727
       -
       

     

       728
       728
       -
               // Only add lifetime if the target type needs it

     

       729
       729
       -
               if self.ref_needs_lifetime(ref_str) {

     

       730
       730
       -
                   Ok(quote! { #path<'a> })

     

       731
       731
       -
               } else {

     

       732
       732
       -
                   Ok(quote! { #path })

     

       733
       733
       -
               }

     

       734
       734
       -
           }

     

       735
       735
       -
       

     

       736
       736
       -
           /// Generate query type

     

       737
       737
       -
           fn generate_query(

     

       738
       738
       -
               &self,

     

       739
       739
       -
               nsid: &str,

     

       740
       740
       -
               def_name: &str,

     

       741
       741
       -
               query: &LexXrpcQuery<'static>,

     

       742
       742
       -
           ) -> Result<TokenStream> {

     

       743
       743
       -
               let type_base = self.def_to_type_name(nsid, def_name);

     

       744
       744
       -
               let mut output = Vec::new();

     

       745
       745
       -
       

     

       746
       746
       -
               let params_has_lifetime = query

     

       747
       747
       -
                   .parameters

     

       748
       748
       -
                   .as_ref()

     

       749
       749
       -
                   .map(|p| match p {

     

       750
       750
       -
                       crate::lexicon::LexXrpcQueryParameter::Params(params) => {

     

       751
       751
       -
                           self.params_need_lifetime(params)

     

       752
       752
       -
                       }

     

       753
       753
       -
                   })

     

       754
       754
       -
                   .unwrap_or(false);

     

       755
       755
       -
               let has_params = query.parameters.is_some();

     

       756
       756
       -
               let has_output = query.output.is_some();

     

       757
       757
       -
               let has_errors = query.errors.is_some();

     

       758
       758
       -
       

     

       759
       759
       -
               if let Some(params) = &query.parameters {

     

       760
       760
       -
                   let params_struct = self.generate_params_struct(&type_base, params)?;

     

       761
       761
       -
                   output.push(params_struct);

     

       762
       762
       -
               }

     

       763
       763
       -
       

     

       764
       764
       -
               if let Some(body) = &query.output {

     

       765
       765
       -
                   let output_struct = self.generate_output_struct(nsid, &type_base, body)?;

     

       766
       766
       -
                   output.push(output_struct);

     

       767
       767
       -
               }

     

       768
       768
       -
       

     

       769
       769
       -
               if let Some(errors) = &query.errors {

     

       770
       770
       -
                   let error_enum = self.generate_error_enum(&type_base, errors)?;

     

       771
       771
       -
                   output.push(error_enum);

     

       772
       772
       -
               }

     

       773
       773
       -
       

     

       774
       774
       -
               // Generate XrpcRequest impl

     

       775
       775
       -
               let output_encoding = query

     

       776
       776
       -
                   .output

     

       777
       777
       -
                   .as_ref()

     

       778
       778
       -
                   .map(|o| o.encoding.as_ref())

     

       779
       779
       -
                   .unwrap_or("application/json");

     

       780
       780
       -
               let xrpc_impl = self.generate_xrpc_request_impl(

     

       781
       781
       -
                   nsid,

     

       782
       782
       -
                   &type_base,

     

       783
       783
       -
                   quote! { jacquard_common::xrpc::XrpcMethod::Query },

     

       784
       784
       -
                   output_encoding,

     

       785
       785
       -
                   has_params,

     

       786
       786
       -
                   params_has_lifetime,

     

       787
       787
       -
                   has_output,

     

       788
       788
       -
                   has_errors,

     

       789
       789
       -
                   false, // queries never have binary inputs

     

       790
       790
       -
               )?;

     

       791
       791
       -
               output.push(xrpc_impl);

     

       792
       792
       -
       

     

       793
       793
       -
               Ok(quote! {

     

       794
       794
       -
                   #(#output)*

     

       795
       795
       -
               })

     

       796
       796
       -
           }

     

       797
       797
       -
       

     

       798
       798
       -
           /// Generate procedure type

     

       799
       799
       -
           fn generate_procedure(

     

       800
       800
       -
               &self,

     

       801
       801
       -
               nsid: &str,

     

       802
       802
       -
               def_name: &str,

     

       803
       803
       -
               proc: &LexXrpcProcedure<'static>,

     

       804
       804
       -
           ) -> Result<TokenStream> {

     

       805
       805
       -
               let type_base = self.def_to_type_name(nsid, def_name);

     

       806
       806
       -
               let mut output = Vec::new();

     

       807
       807
       -
       

     

       808
       808
       -
               // Check if input is a binary body (no schema)

     

       809
       809
       -
               let is_binary_input = proc

     

       810
       810
       -
                   .input

     

       811
       811
       -
                   .as_ref()

     

       812
       812
       -
                   .map(|i| i.schema.is_none())

     

       813
       813
       -
                   .unwrap_or(false);

     

       814
       814
       -
       

     

       815
       815
       -
               // Input bodies with schemas have lifetimes (they get #[lexicon] attribute)

     

       816
       816
       -
               // Binary inputs don't have lifetimes

     

       817
       817
       -
               let params_has_lifetime = proc.input.is_some() && !is_binary_input;

     

       818
       818
       -
               let has_input = proc.input.is_some();

     

       819
       819
       -
               let has_output = proc.output.is_some();

     

       820
       820
       -
               let has_errors = proc.errors.is_some();

     

       821
       821
       -
       

     

       822
       822
       -
               if let Some(params) = &proc.parameters {

     

       823
       823
       -
                   let params_struct = self.generate_params_struct_proc(&type_base, params)?;

     

       824
       824
       -
                   output.push(params_struct);

     

       825
       825
       -
               }

     

       826
       826
       -
       

     

       827
       827
       -
               if let Some(body) = &proc.input {

     

       828
       828
       -
                   let input_struct = self.generate_input_struct(nsid, &type_base, body)?;

     

       829
       829
       -
                   output.push(input_struct);

     

       830
       830
       -
               }

     

       831
       831
       -
       

     

       832
       832
       -
               if let Some(body) = &proc.output {

     

       833
       833
       -
                   let output_struct = self.generate_output_struct(nsid, &type_base, body)?;

     

       834
       834
       -
                   output.push(output_struct);

     

       835
       835
       -
               }

     

       836
       836
       -
       

     

       837
       837
       -
               if let Some(errors) = &proc.errors {

     

       838
       838
       -
                   let error_enum = self.generate_error_enum(&type_base, errors)?;

     

       839
       839
       -
                   output.push(error_enum);

     

       840
       840
       -
               }

     

       841
       841
       -
       

     

       842
       842
       -
               // Generate XrpcRequest impl

     

       843
       843
       -
               let input_encoding = proc

     

       844
       844
       -
                   .input

     

       845
       845
       -
                   .as_ref()

     

       846
       846
       -
                   .map(|i| i.encoding.as_ref())

     

       847
       847
       -
                   .unwrap_or("application/json");

     

       848
       848
       -
               let output_encoding = proc

     

       849
       849
       -
                   .output

     

       850
       850
       -
                   .as_ref()

     

       851
       851
       -
                   .map(|o| o.encoding.as_ref())

     

       852
       852
       -
                   .unwrap_or("application/json");

     

       853
       853
       -
               let xrpc_impl = self.generate_xrpc_request_impl(

     

       854
       854
       -
                   nsid,

     

       855
       855
       -
                   &type_base,

     

       856
       856
       -
                   quote! { jacquard_common::xrpc::XrpcMethod::Procedure(#input_encoding) },

     

       857
       857
       -
                   output_encoding,

     

       858
       858
       -
                   has_input,

     

       859
       859
       -
                   params_has_lifetime,

     

       860
       860
       -
                   has_output,

     

       861
       861
       -
                   has_errors,

     

       862
       862
       -
                   is_binary_input,

     

       863
       863
       -
               )?;

     

       864
       864
       -
               output.push(xrpc_impl);

     

       865
       865
       -
       

     

       866
       866
       -
               Ok(quote! {

     

       867
       867
       -
                   #(#output)*

     

       868
       868
       -
               })

     

       869
       869
       -
           }

     

       870
       870
       -
       

     

       871
       871
       -
           fn generate_subscription(

     

       872
       872
       -
               &self,

     

       873
       873
       -
               nsid: &str,

     

       874
       874
       -
               def_name: &str,

     

       875
       875
       -
               sub: &LexXrpcSubscription<'static>,

     

       876
       876
       -
           ) -> Result<TokenStream> {

     

       877
       877
       -
               let type_base = self.def_to_type_name(nsid, def_name);

     

       878
       878
       -
               let mut output = Vec::new();

     

       879
       879
       -
       

     

       880
       880
       -
               if let Some(params) = &sub.parameters {

     

       881
       881
       -
                   // Extract LexXrpcParameters from the enum

     

       882
       882
       -
                   match params {

     

       883
       883
       -
                       crate::lexicon::LexXrpcSubscriptionParameter::Params(params_inner) => {

     

       884
       884
       -
                           let params_struct =

     

       885
       885
       -
                               self.generate_params_struct_inner(&type_base, params_inner)?;

     

       886
       886
       -
                           output.push(params_struct);

     

       887
       887
       -
                       }

     

       888
       888
       -
                   }

     

       889
       889
       -
               }

     

       890
       890
       -
       

     

       891
       891
       -
               if let Some(message) = &sub.message {

     

       892
       892
       -
                   if let Some(schema) = &message.schema {

     

       893
       893
       -
                       let message_type = self.generate_subscription_message(nsid, &type_base, schema)?;

     

       894
       894
       -
                       output.push(message_type);

     

       895
       895
       -
                   }

     

       896
       896
       -
               }

     

       897
       897
       -
       

     

       898
       898
       -
               if let Some(errors) = &sub.errors {

     

       899
       899
       -
                   let error_enum = self.generate_error_enum(&type_base, errors)?;

     

       900
       900
       -
                   output.push(error_enum);

     

       901
       901
       -
               }

     

       902
       902
       -
       

     

       903
       903
       -
               Ok(quote! {

     

       904
       904
       -
                   #(#output)*

     

       905
       905
       -
               })

     

       906
       906
       -
           }

     

       907
       907
       -
       

     

       908
       908
       -
           fn generate_subscription_message(

     

       909
       909
       -
               &self,

     

       910
       910
       -
               nsid: &str,

     

       911
       911
       -
               type_base: &str,

     

       912
       912
       -
               schema: &LexXrpcSubscriptionMessageSchema<'static>,

     

       913
       913
       -
           ) -> Result<TokenStream> {

     

       914
       914
       -
               use crate::lexicon::LexXrpcSubscriptionMessageSchema;

     

       915
       915
       -
       

     

       916
       916
       -
               match schema {

     

       917
       917
       -
                   LexXrpcSubscriptionMessageSchema::Union(union) => {

     

       918
       918
       -
                       // Generate a union enum for the message

     

       919
       919
       -
                       let enum_name = format!("{}Message", type_base);

     

       920
       920
       -
                       let enum_ident = syn::Ident::new(&enum_name, proc_macro2::Span::call_site());

     

       921
       921
       -
       

     

       922
       922
       -
                       let mut variants = Vec::new();

     

       923
       923
       -
                       for ref_str in &union.refs {

     

       924
       924
       -
                           let ref_str_s = ref_str.as_ref();

     

       925
       925
       -
                           // Parse ref to get NSID and def name

     

       926
       926
       -
                           let (ref_nsid, ref_def) =

     

       927
       927
       -
                               if let Some((nsid, fragment)) = ref_str.split_once('#') {

     

       928
       928
       -
                                   (nsid, fragment)

     

       929
       929
       -
                               } else {

     

       930
       930
       -
                                   (ref_str.as_ref(), "main")

     

       931
       931
       -
                               };

     

       932
       932
       -
       

     

       933
       933
       -
                           let variant_name = if ref_def == "main" {

     

       934
       934
       -
                               ref_nsid.split('.').last().unwrap().to_pascal_case()

     

       935
       935
       -
                           } else {

     

       936
       936
       -
                               ref_def.to_pascal_case()

     

       937
       937
       -
                           };

     

       938
       938
       -
                           let variant_ident =

     

       939
       939
       -
                               syn::Ident::new(&variant_name, proc_macro2::Span::call_site());

     

       940
       940
       -
                           let type_path = self.ref_to_rust_type(ref_str)?;

     

       941
       941
       -
       

     

       942
       942
       -
                           variants.push(quote! {

     

       943
       943
       -
                               #[serde(rename = #ref_str_s)]

     

       944
       944
       -
                               #variant_ident(Box<#type_path>)

     

       945
       945
       -
                           });

     

       946
       946
       -
                       }

     

       947
       947
       -
       

     

       948
       948
       -
                       let doc = self.generate_doc_comment(union.description.as_ref());

     

       949
       949
       -
       

     

       950
       950
       -
                       // Generate IntoStatic impl for the enum

     

       951
       951
       -
                       // let variant_info: Vec<(String, EnumVariantKind)> = union

     

       952
       952
       -
                       //     .refs

     

       953
       953
       -
                       //     .iter()

     

       954
       954
       -
                       //     .map(|ref_str| {

     

       955
       955
       -
                       //         let ref_def = if let Some((_, fragment)) = ref_str.split_once('#') {

     

       956
       956
       -
                       //             fragment

     

       957
       957
       -
                       //         } else {

     

       958
       958
       -
                       //             "main"

     

       959
       959
       -
                       //         };

     

       960
       960
       -
                       //         let variant_name = if ref_def == "main" {

     

       961
       961
       -
                       //             ref_str.split('.').last().unwrap().to_pascal_case()

     

       962
       962
       -
                       //         } else {

     

       963
       963
       -
                       //             ref_def.to_pascal_case()

     

       964
       964
       -
                       //         };

     

       965
       965
       -
                       //         (variant_name, EnumVariantKind::Tuple)

     

       966
       966
       -
                       //     })

     

       967
       967
       -
                       //     .collect();

     

       968
       968
       -
                       // let into_static_impl = self.generate_into_static_for_enum(

     

       969
       969
       -
                       //     &enum_name,

     

       970
       970
       -
                       //     &variant_info,

     

       971
       971
       -
                       //     true,

     

       972
       972
       -
                       //     true, // open union

     

       973
       973
       -
                       // );

     

       974
       974
       -
       

     

       975
       975
       -
                       Ok(quote! {

     

       976
       976
       -
                           #doc

     

       977
       977
       -
                           #[jacquard_derive::open_union]

     

       978
       978
       -
                           #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       979
       979
       -
                           #[serde(tag = "$type")]

     

       980
       980
       -
                           #[serde(bound(deserialize = "'de: 'a"))]

     

       981
       981
       -
                           pub enum #enum_ident<'a> {

     

       982
       982
       -
                               #(#variants,)*

     

       983
       983
       -
                           }

     

       984
       984
       -
       

     

       985
       985
       -
                           //#into_static_impl

     

       986
       986
       -
                       })

     

       987
       987
       -
                   }

     

       988
       988
       -
                   LexXrpcSubscriptionMessageSchema::Object(obj) => {

     

       989
       989
       -
                       // Generate a struct for the message

     

       990
       990
       -
                       let struct_name = format!("{}Message", type_base);

     

       991
       991
       -
                       let struct_ident = syn::Ident::new(&struct_name, proc_macro2::Span::call_site());

     

       992
       992
       -
       

     

       993
       993
       -
                       let fields = self.generate_object_fields("", &struct_name, obj, false)?;

     

       994
       994
       -
                       let doc = self.generate_doc_comment(obj.description.as_ref());

     

       995
       995
       -
       

     

       996
       996
       -
                       // Subscription message structs always get a lifetime since they have the #[lexicon] attribute

     

       997
       997
       -
                       // which adds extra_data: BTreeMap<..., Data<'a>>

     

       998
       998
       -
                       let struct_def = quote! {

     

       999
       999
       -
                           #doc

     

       1000
       1000
       -
                           #[jacquard_derive::lexicon]

     

       1001
       1001
       -
                           #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       1002
       1002
       -
                           #[serde(rename_all = "camelCase")]

     

       1003
       1003
       -
                           pub struct #struct_ident<'a> {

     

       1004
       1004
       -
                               #fields

     

       1005
       1005
       -
                           }

     

       1006
       1006
       -
                       };

     

       1007
       1007
       -
       

     

       1008
       1008
       -
                       // Generate union types for this message

     

       1009
       1009
       -
                       let mut unions = Vec::new();

     

       1010
       1010
       -
                       for (field_name, field_type) in &obj.properties {

     

       1011
       1011
       -
                           if let LexObjectProperty::Union(union) = field_type {

     

       1012
       1012
       -
                               let union_name =

     

       1013
       1013
       -
                                   format!("{}Record{}", struct_name, field_name.to_pascal_case());

     

       1014
       1014
       -
                               let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       1015
       1015
       -
                               let union_def =

     

       1016
       1016
       -
                                   self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       1017
       1017
       -
                               unions.push(union_def);

     

       1018
       1018
       -
                           }

     

       1019
       1019
       -
                       }

     

       1020
       1020
       -
       

     

       1021
       1021
       -
                       // Generate IntoStatic impl

     

       1022
       1022
       -
                       // let field_names: Vec<&str> = obj.properties.keys().map(|k| k.as_str()).collect();

     

       1023
       1023
       -
                       // let into_static_impl =

     

       1024
       1024
       -
                       //     self.generate_into_static_for_struct(&struct_name, &field_names, true, true);

     

       1025
       1025
       -
       

     

       1026
       1026
       -
                       Ok(quote! {

     

       1027
       1027
       -
                           #struct_def

     

       1028
       1028
       -
                           #(#unions)*

     

       1029
       1029
       -
                           //#into_static_impl

     

       1030
       1030
       -
                       })

     

       1031
       1031
       -
                   }

     

       1032
       1032
       -
                   LexXrpcSubscriptionMessageSchema::Ref(ref_type) => {

     

       1033
       1033
       -
                       // Just a type alias to the referenced type

     

       1034
       1034
       -
                       // Refs generally have lifetimes, so always add <'a>

     

       1035
       1035
       -
                       let type_name = format!("{}Message", type_base);

     

       1036
       1036
       -
                       let ident = syn::Ident::new(&type_name, proc_macro2::Span::call_site());

     

       1037
       1037
       -
                       let rust_type = self.ref_to_rust_type(&ref_type.r#ref)?;

     

       1038
       1038
       -
                       let doc = self.generate_doc_comment(ref_type.description.as_ref());

     

       1039
       1039
       -
       

     

       1040
       1040
       -
                       Ok(quote! {

     

       1041
       1041
       -
                           #doc

     

       1042
       1042
       -
                           pub type #ident<'a> = #rust_type;

     

       1043
       1043
       -
                       })

     

       1044
       1044
       -
                   }

     

       1045
       1045
       -
               }

     

       1046
       1046
       -
           }

     

       1047
       1047
       -
       

     

       1048
       1048
       -
           /// Convert def name to Rust type name

     

       1049
       1049
       -
           fn def_to_type_name(&self, nsid: &str, def_name: &str) -> String {

     

       1050
       1050
       -
               if def_name == "main" {

     

       1051
       1051
       -
                   // Use last segment of NSID

     

       1052
       1052
       -
                   let base_name = nsid.split('.').last().unwrap().to_pascal_case();

     

       1053
       1053
       -
       

     

       1054
       1054
       -
                   // Check if any other def would collide with this name

     

       1055
       1055
       -
                   if let Some(doc) = self.corpus.get(nsid) {

     

       1056
       1056
       -
                       let has_collision = doc.defs.keys().any(|other_def| {

     

       1057
       1057
       -
                           let other_def_str: &str = other_def.as_ref();

     

       1058
       1058
       -
                           other_def_str != "main" && other_def_str.to_pascal_case() == base_name

     

       1059
       1059
       -
                       });

     

       1060
       1060
       -
       

     

       1061
       1061
       -
                       if has_collision {

     

       1062
       1062
       -
                           return format!("{}Record", base_name);

     

       1063
       1063
       -
                       }

     

       1064
       1064
       -
                   }

     

       1065
       1065
       -
       

     

       1066
       1066
       -
                   base_name

     

       1067
       1067
       -
               } else {

     

       1068
       1068
       -
                   def_name.to_pascal_case()

     

       1069
       1069
       -
               }

     

       1070
       1070
       -
           }

     

       1071
       1071
       -
       

     

       1072
       1072
       -
           /// Convert NSID to file path relative to output directory

     

       1073
       1073
       -
           ///

     

       1074
       1074
       -
           /// - `app.bsky.feed.post` → `app_bsky/feed/post.rs`

     

       1075
       1075
       -
           /// - `com.atproto.label.defs` → `com_atproto/label.rs` (defs go in parent)

     

       1076
       1076
       -
           fn nsid_to_file_path(&self, nsid: &str) -> std::path::PathBuf {

     

       1077
       1077
       -
               let parts: Vec<&str> = nsid.split('.').collect();

     

       1078
       1078
       -
       

     

       1079
       1079
       -
               if parts.len() < 2 {

     

       1080
       1080
       -
                   // Shouldn't happen with valid NSIDs, but handle gracefully

     

       1081
       1081
       -
                   return format!("{}.rs", sanitize_name(parts[0])).into();

     

       1082
       1082
       -
               }

     

       1083
       1083
       -
       

     

       1084
       1084
       -
               let last = parts.last().unwrap();

     

       1085
       1085
       -
       

     

       1086
       1086
       -
               if *last == "defs" && parts.len() >= 3 {

     

       1087
       1087
       -
                   // defs go in parent module: com.atproto.label.defs → com_atproto/label.rs

     

       1088
       1088
       -
                   let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1]));

     

       1089
       1089
       -
                   if parts.len() == 3 {

     

       1090
       1090
       -
                       // com.atproto.defs → com_atproto.rs

     

       1091
       1091
       -
                       format!("{}.rs", first_two).into()

     

       1092
       1092
       -
                   } else {

     

       1093
       1093
       -
                       // com.atproto.label.defs → com_atproto/label.rs

     

       1094
       1094
       -
                       let middle: Vec<&str> = parts[2..parts.len() - 1].iter().copied().collect();

     

       1095
       1095
       -
                       let mut path = std::path::PathBuf::from(first_two);

     

       1096
       1096
       -
                       for segment in &middle[..middle.len() - 1] {

     

       1097
       1097
       -
                           path.push(sanitize_name(segment));

     

       1098
       1098
       -
                       }

     

       1099
       1099
       -
                       path.push(format!("{}.rs", sanitize_name(middle.last().unwrap())));

     

       1100
       1100
       -
                       path

     

       1101
       1101
       -
                   }

     

       1102
       1102
       -
               } else {

     

       1103
       1103
       -
                   // Regular path: app.bsky.feed.post → app_bsky/feed/post.rs

     

       1104
       1104
       -
                   let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1]));

     

       1105
       1105
       -
                   let mut path = std::path::PathBuf::from(first_two);

     

       1106
       1106
       -
       

     

       1107
       1107
       -
                   for segment in &parts[2..parts.len() - 1] {

     

       1108
       1108
       -
                       path.push(sanitize_name(segment));

     

       1109
       1109
       -
                   }

     

       1110
       1110
       -
       

     

       1111
       1111
       -
                   path.push(format!("{}.rs", sanitize_name(&last.to_snake_case())));

     

       1112
       1112
       -
                   path

     

       1113
       1113
       -
               }

     

       1114
       1114
       -
           }

     

       1115
       1115
       -
       

     

       1116
       1116
       -
           /// Generate all code for the corpus, organized by file

     

       1117
       1117
       -
           /// Returns a map of file paths to (tokens, optional NSID)

     

       1118
       1118
       -
           pub fn generate_all(

     

       1119
       1119
       -
               &self,

     

       1120
       1120
       -
           ) -> Result<std::collections::BTreeMap<std::path::PathBuf, (TokenStream, Option<String>)>> {

     

       1121
       1121
       -
               use std::collections::BTreeMap;

     

       1122
       1122
       -
       

     

       1123
       1123
       -
               let mut file_contents: BTreeMap<std::path::PathBuf, Vec<TokenStream>> = BTreeMap::new();

     

       1124
       1124
       -
               let mut file_nsids: BTreeMap<std::path::PathBuf, String> = BTreeMap::new();

     

       1125
       1125
       -
       

     

       1126
       1126
       -
               // Generate code for all lexicons

     

       1127
       1127
       -
               for (nsid, doc) in self.corpus.iter() {

     

       1128
       1128
       -
                   let file_path = self.nsid_to_file_path(nsid.as_ref());

     

       1129
       1129
       -
       

     

       1130
       1130
       -
                   // Track which NSID this file is for

     

       1131
       1131
       -
                   file_nsids.insert(file_path.clone(), nsid.to_string());

     

       1132
       1132
       -
       

     

       1133
       1133
       -
                   for (def_name, def) in &doc.defs {

     

       1134
       1134
       -
                       let tokens = self.generate_def(nsid.as_ref(), def_name.as_ref(), def)?;

     

       1135
       1135
       -
                       file_contents

     

       1136
       1136
       -
                           .entry(file_path.clone())

     

       1137
       1137
       -
                           .or_default()

     

       1138
       1138
       -
                           .push(tokens);

     

       1139
       1139
       -
                   }

     

       1140
       1140
       -
               }

     

       1141
       1141
       -
       

     

       1142
       1142
       -
               // Combine all tokens for each file

     

       1143
       1143
       -
               let mut result = BTreeMap::new();

     

       1144
       1144
       -
               for (path, tokens_vec) in file_contents {

     

       1145
       1145
       -
                   let nsid = file_nsids.get(&path).cloned();

     

       1146
       1146
       -
                   result.insert(path, (quote! { #(#tokens_vec)* }, nsid));

     

       1147
       1147
       -
               }

     

       1148
       1148
       -
       

     

       1149
       1149
       -
               Ok(result)

     

       1150
       1150
       -
           }

     

       1151
       1151
       -
       

     

       1152
       1152
       -
           /// Generate parent module files with pub mod declarations

     

       1153
       1153
       -
           pub fn generate_module_tree(

     

       1154
       1154
       -
               &self,

     

       1155
       1155
       -
               file_map: &std::collections::BTreeMap<std::path::PathBuf, (TokenStream, Option<String>)>,

     

       1156
       1156
       -
               defs_only: &std::collections::BTreeMap<std::path::PathBuf, (TokenStream, Option<String>)>,

     

       1157
       1157
       -
           ) -> std::collections::BTreeMap<std::path::PathBuf, (TokenStream, Option<String>)> {

     

       1158
       1158
       -
               use std::collections::{BTreeMap, BTreeSet};

     

       1159
       1159
       -
       

     

       1160
       1160
       -
               // Track what modules each directory needs to declare

     

       1161
       1161
       -
               // Key: directory path, Value: set of module names (file stems)

     

       1162
       1162
       -
               let mut dir_modules: BTreeMap<std::path::PathBuf, BTreeSet<String>> = BTreeMap::new();

     

       1163
       1163
       -
       

     

       1164
       1164
       -
               // Collect all parent directories that have files

     

       1165
       1165
       -
               let mut all_dirs: BTreeSet<std::path::PathBuf> = BTreeSet::new();

     

       1166
       1166
       -
               for path in file_map.keys() {

     

       1167
       1167
       -
                   if let Some(parent_dir) = path.parent() {

     

       1168
       1168
       -
                       all_dirs.insert(parent_dir.to_path_buf());

     

       1169
       1169
       -
                   }

     

       1170
       1170
       -
               }

     

       1171
       1171
       -
       

     

       1172
       1172
       -
               for path in file_map.keys() {

     

       1173
       1173
       -
                   if let Some(parent_dir) = path.parent() {

     

       1174
       1174
       -
                       if let Some(file_stem) = path.file_stem().and_then(|s| s.to_str()) {

     

       1175
       1175
       -
                           // Skip mod.rs and lib.rs - they're module files, not modules to declare

     

       1176
       1176
       -
                           if file_stem == "mod" || file_stem == "lib" {

     

       1177
       1177
       -
                               continue;

     

       1178
       1178
       -
                           }

     

       1179
       1179
       -
       

     

       1180
       1180
       -
                           // Always add the module declaration to parent

     

       1181
       1181
       -
                           dir_modules

     

       1182
       1182
       -
                               .entry(parent_dir.to_path_buf())

     

       1183
       1183
       -
                               .or_default()

     

       1184
       1184
       -
                               .insert(file_stem.to_string());

     

       1185
       1185
       -
                       }

     

       1186
       1186
       -
                   }

     

       1187
       1187
       -
               }

     

       1188
       1188
       -
       

     

       1189
       1189
       -
               // Generate module files

     

       1190
       1190
       -
               let mut result = BTreeMap::new();

     

       1191
       1191
       -
       

     

       1192
       1192
       -
               for (dir, module_names) in dir_modules {

     

       1193
       1193
       -
                   let mod_file_path = if dir.components().count() == 0 {

     

       1194
       1194
       -
                       // Root directory -> lib.rs for library crates

     

       1195
       1195
       -
                       std::path::PathBuf::from("lib.rs")

     

       1196
       1196
       -
                   } else {

     

       1197
       1197
       -
                       // Subdirectory: app_bsky/feed -> app_bsky/feed.rs (Rust 2018 style)

     

       1198
       1198
       -
                       let dir_name = dir.file_name().and_then(|s| s.to_str()).unwrap_or("mod");

     

       1199
       1199
       -
                       let sanitized_dir_name = sanitize_name(dir_name);

     

       1200
       1200
       -
                       let mut path = dir

     

       1201
       1201
       -
                           .parent()

     

       1202
       1202
       -
                           .unwrap_or_else(|| std::path::Path::new(""))

     

       1203
       1203
       -
                           .to_path_buf();

     

       1204
       1204
       -
                       path.push(format!("{}.rs", sanitized_dir_name));

     

       1205
       1205
       -
                       path

     

       1206
       1206
       -
                   };

     

       1207
       1207
       -
       

     

       1208
       1208
       -
                   let is_root = dir.components().count() == 0;

     

       1209
       1209
       -
                   let mods: Vec<_> = module_names

     

       1210
       1210
       -
                       .iter()

     

       1211
       1211
       -
                       .map(|name| {

     

       1212
       1212
       -
                           let ident = make_ident(name);

     

       1213
       1213
       -
                           if is_root {

     

       1214
       1214
       -
                               // Top-level modules get feature gates

     

       1215
       1215
       -
                               quote! {

     

       1216
       1216
       -
                                   #[cfg(feature = #name)]

     

       1217
       1217
       -
                                   pub mod #ident;

     

       1218
       1218
       -
                               }

     

       1219
       1219
       -
                           } else {

     

       1220
       1220
       -
                               quote! { pub mod #ident; }

     

       1221
       1221
       -
                           }

     

       1222
       1222
       -
                       })

     

       1223
       1223
       -
                       .collect();

     

       1224
       1224
       -
       

     

       1225
       1225
       -
                   // If this file already exists in defs_only (e.g., from defs), merge the content

     

       1226
       1226
       -
                   let module_tokens = quote! { #(#mods)* };

     

       1227
       1227
       -
                   if let Some((existing_tokens, nsid)) = defs_only.get(&mod_file_path) {

     

       1228
       1228
       -
                       // Put module declarations FIRST, then existing defs content

     

       1229
       1229
       -
                       result.insert(

     

       1230
       1230
       -
                           mod_file_path,

     

       1231
       1231
       -
                           (quote! { #module_tokens #existing_tokens }, nsid.clone()),

     

       1232
       1232
       -
                       );

     

       1233
       1233
       -
                   } else {

     

       1234
       1234
       -
                       result.insert(mod_file_path, (module_tokens, None));

     

       1235
       1235
       -
                   }

     

       1236
       1236
       -
               }

     

       1237
       1237
       -
       

     

       1238
       1238
       -
               result

     

       1239
       1239
       -
           }

     

       1240
       1240
       -
       

     

       1241
       1241
       -
           /// Write all generated code to disk

     

       1242
       1242
       -
           pub fn write_to_disk(&self, output_dir: &std::path::Path) -> Result<()> {

     

       1243
       1243
       -
               // Generate all code (defs only)

     

       1244
       1244
       -
               let defs_files = self.generate_all()?;

     

       1245
       1245
       -
               let mut all_files = defs_files.clone();

     

       1246
       1246
       -
       

     

       1247
       1247
       -
               // Generate module tree iteratively until no new files appear

     

       1248
       1248
       -
               loop {

     

       1249
       1249
       -
                   let module_map = self.generate_module_tree(&all_files, &defs_files);

     

       1250
       1250
       -
                   let old_count = all_files.len();

     

       1251
       1251
       -
       

     

       1252
       1252
       -
                   // Merge new module files

     

       1253
       1253
       -
                   for (path, tokens) in module_map {

     

       1254
       1254
       -
                       all_files.insert(path, tokens);

     

       1255
       1255
       -
                   }

     

       1256
       1256
       -
       

     

       1257
       1257
       -
                   if all_files.len() == old_count {

     

       1258
       1258
       -
                       // No new files added

     

       1259
       1259
       -
                       break;

     

       1260
       1260
       -
                   }

     

       1261
       1261
       -
               }

     

       1262
       1262
       -
       

     

       1263
       1263
       -
               // Write to disk

     

       1264
       1264
       -
               for (path, (tokens, nsid)) in all_files {

     

       1265
       1265
       -
                   let full_path = output_dir.join(&path);

     

       1266
       1266
       -
       

     

       1267
       1267
       -
                   // Create parent directories

     

       1268
       1268
       -
                   if let Some(parent) = full_path.parent() {

     

       1269
       1269
       -
                       std::fs::create_dir_all(parent).map_err(|e| CodegenError::Other {

     

       1270
       1270
       -
                           message: format!("Failed to create directory {:?}: {}", parent, e),

     

       1271
       1271
       -
                           source: None,

     

       1272
       1272
       -
                       })?;

     

       1273
       1273
       -
                   }

     

       1274
       1274
       -
       

     

       1275
       1275
       -
                   // Format code

     

       1276
       1276
       -
                   let file: syn::File = syn::parse2(tokens.clone()).map_err(|e| CodegenError::Other {

     

       1277
       1277
       -
                       message: format!(

     

       1278
       1278
       -
                           "Failed to parse tokens for {:?}: {}\nTokens: {}",

     

       1279
       1279
       -
                           path, e, tokens

     

       1280
       1280
       -
                       ),

     

       1281
       1281
       -
                       source: None,

     

       1282
       1282
       -
                   })?;

     

       1283
       1283
       -
                   let mut formatted = prettyplease::unparse(&file);

     

       1284
       1284
       -
       

     

       1285
       1285
       -
                   // Add blank lines between top-level items for better readability

     

       1286
       1286
       -
                   let lines: Vec<&str> = formatted.lines().collect();

     

       1287
       1287
       -
                   let mut result_lines = Vec::new();

     

       1288
       1288
       -
       

     

       1289
       1289
       -
                   for (i, line) in lines.iter().enumerate() {

     

       1290
       1290
       -
                       result_lines.push(*line);

     

       1291
       1291
       -
       

     

       1292
       1292
       -
                       // Add blank line after closing braces that are at column 0 (top-level items)

     

       1293
       1293
       -
                       if *line == "}" && i + 1 < lines.len() && !lines[i + 1].is_empty() {

     

       1294
       1294
       -
                           result_lines.push("");

     

       1295
       1295
       -
                       }

     

       1296
       1296
       -
       

     

       1297
       1297
       -
                       // Add blank line after last pub mod declaration before structs/enums

     

       1298
       1298
       -
                       if line.starts_with("pub mod ") && i + 1 < lines.len() {

     

       1299
       1299
       -
                           let next_line = lines[i + 1];

     

       1300
       1300
       -
                           if !next_line.starts_with("pub mod ") && !next_line.is_empty() {

     

       1301
       1301
       -
                               result_lines.push("");

     

       1302
       1302
       -
                           }

     

       1303
       1303
       -
                       }

     

       1304
       1304
       -
                   }

     

       1305
       1305
       -
       

     

       1306
       1306
       -
                   formatted = result_lines.join("\n");

     

       1307
       1307
       -
       

     

       1308
       1308
       -
                   // Add header comment

     

       1309
       1309
       -
                   let header = if let Some(nsid) = nsid {

     

       1310
       1310
       -
                       format!(

     

       1311
       1311
       -
                           "// @generated by jacquard-lexicon. DO NOT EDIT.\n//\n// Lexicon: {}\n//\n// This file was automatically generated from Lexicon schemas.\n// Any manual changes will be overwritten on the next regeneration.\n\n",

     

       1312
       1312
       -
                           nsid

     

       1313
       1313
       -
                       )

     

       1314
       1314
       -
                   } else {

     

       1315
       1315
       -
                       "// @generated by jacquard-lexicon. DO NOT EDIT.\n//\n// This file was automatically generated from Lexicon schemas.\n// Any manual changes will be overwritten on the next regeneration.\n\n".to_string()

     

       1316
       1316
       -
                   };

     

       1317
       1317
       -
                   formatted = format!("{}{}", header, formatted);

     

       1318
       1318
       -
       

     

       1319
       1319
       -
                   // Write file

     

       1320
       1320
       -
                   std::fs::write(&full_path, formatted).map_err(|e| CodegenError::Other {

     

       1321
       1321
       -
                       message: format!("Failed to write file {:?}: {}", full_path, e),

     

       1322
       1322
       -
                       source: None,

     

       1323
       1323
       -
                   })?;

     

       1324
       1324
       -
               }

     

       1325
       1325
       -
       

     

       1326
       1326
       -
               Ok(())

     

       1327
       1327
       -
           }

     

       1328
       1328
       -
       

     

       1329
       1329
       -
           /// Generate doc comment from description

     

       1330
       1330
       -
           fn generate_doc_comment(&self, desc: Option<&jacquard_common::CowStr>) -> TokenStream {

     

       1331
       1331
       -
               if let Some(desc) = desc {

     

       1332
       1332
       -
                   let doc = desc.as_ref();

     

       1333
       1333
       -
                   quote! { #[doc = #doc] }

     

       1334
       1334
       -
               } else {

     

       1335
       1335
       -
                   quote! {}

     

       1336
       1336
       -
               }

     

       1337
       1337
       -
           }

     

       1338
       1338
       -
       

     

       1339
       1339
       -
           /// Generate params struct from XRPC query parameters

     

       1340
       1340
       -
           fn generate_params_struct(

     

       1341
       1341
       -
               &self,

     

       1342
       1342
       -
               type_base: &str,

     

       1343
       1343
       -
               params: &crate::lexicon::LexXrpcQueryParameter<'static>,

     

       1344
       1344
       -
           ) -> Result<TokenStream> {

     

       1345
       1345
       -
               use crate::lexicon::LexXrpcQueryParameter;

     

       1346
       1346
       -
               match params {

     

       1347
       1347
       -
                   LexXrpcQueryParameter::Params(p) => self.generate_params_struct_inner(type_base, p),

     

       1348
       1348
       -
               }

     

       1349
       1349
       -
           }

     

       1350
       1350
       -
       

     

       1351
       1351
       -
           /// Generate params struct from XRPC procedure parameters (query string params)

     

       1352
       1352
       -
           fn generate_params_struct_proc(

     

       1353
       1353
       -
               &self,

     

       1354
       1354
       -
               type_base: &str,

     

       1355
       1355
       -
               params: &crate::lexicon::LexXrpcProcedureParameter<'static>,

     

       1356
       1356
       -
           ) -> Result<TokenStream> {

     

       1357
       1357
       -
               use crate::lexicon::LexXrpcProcedureParameter;

     

       1358
       1358
       -
               match params {

     

       1359
       1359
       -
                   // For procedures, query string params still get "Params" suffix since the main struct is the input

     

       1360
       1360
       -
                   LexXrpcProcedureParameter::Params(p) => {

     

       1361
       1361
       -
                       let struct_name = format!("{}Params", type_base);

     

       1362
       1362
       -
                       let ident = syn::Ident::new(&struct_name, proc_macro2::Span::call_site());

     

       1363
       1363
       -
                       self.generate_params_struct_inner_with_name(&ident, p)

     

       1364
       1364
       -
                   }

     

       1365
       1365
       -
               }

     

       1366
       1366
       -
           }

     

       1367
       1367
       -
       

     

       1368
       1368
       -
           /// Generate params struct inner (shared implementation)

     

       1369
       1369
       -
           fn generate_params_struct_inner(

     

       1370
       1370
       -
               &self,

     

       1371
       1371
       -
               type_base: &str,

     

       1372
       1372
       -
               p: &crate::lexicon::LexXrpcParameters<'static>,

     

       1373
       1373
       -
           ) -> Result<TokenStream> {

     

       1374
       1374
       -
               let ident = syn::Ident::new(type_base, proc_macro2::Span::call_site());

     

       1375
       1375
       -
               self.generate_params_struct_inner_with_name(&ident, p)

     

       1376
       1376
       -
           }

     

       1377
       1377
       -
       

     

       1378
       1378
       -
           /// Generate params struct with custom name

     

       1379
       1379
       -
           fn generate_params_struct_inner_with_name(

     

       1380
       1380
       -
               &self,

     

       1381
       1381
       -
               ident: &syn::Ident,

     

       1382
       1382
       -
               p: &crate::lexicon::LexXrpcParameters<'static>,

     

       1383
       1383
       -
           ) -> Result<TokenStream> {

     

       1384
       1384
       -
               let required = p.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]);

     

       1385
       1385
       -
               let mut fields = Vec::new();

     

       1386
       1386
       -
               let mut default_fns = Vec::new();

     

       1387
       1387
       -
       

     

       1388
       1388
       -
               for (field_name, field_type) in &p.properties {

     

       1389
       1389
       -
                   let is_required = required.contains(field_name);

     

       1390
       1390
       -
                   let (field_tokens, default_fn) =

     

       1391
       1391
       -
                       self.generate_param_field_with_default("", field_name, field_type, is_required)?;

     

       1392
       1392
       -
                   fields.push(field_tokens);

     

       1393
       1393
       -
                   if let Some(fn_def) = default_fn {

     

       1394
       1394
       -
                       default_fns.push(fn_def);

     

       1395
       1395
       -
                   }

     

       1396
       1396
       -
               }

     

       1397
       1397
       -
       

     

       1398
       1398
       -
               let doc = self.generate_doc_comment(p.description.as_ref());

     

       1399
       1399
       -
               let needs_lifetime = self.params_need_lifetime(p);

     

       1400
       1400
       -
       

     

       1401
       1401
       -
               let derives = quote! {

     

       1402
       1402
       -
                   #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder, jacquard_derive::IntoStatic)]

     

       1403
       1403
       -
                   #[builder(start_fn = new)]

     

       1404
       1404
       -
               };

     

       1405
       1405
       -
       

     

       1406
       1406
       -
               // Generate IntoStatic impl

     

       1407
       1407
       -
               // let field_names: Vec<&str> = p.properties.keys().map(|k| k.as_str()).collect();

     

       1408
       1408
       -
               // let type_name = ident.to_string();

     

       1409
       1409
       -
               // let into_static_impl =

     

       1410
       1410
       -
               //     self.generate_into_static_for_struct(&type_name, &field_names, needs_lifetime, false);

     

       1411
       1411
       -
       

     

       1412
       1412
       -
               if needs_lifetime {

     

       1413
       1413
       -
                   Ok(quote! {

     

       1414
       1414
       -
                       #(#default_fns)*

     

       1415
       1415
       -
       

     

       1416
       1416
       -
                       #doc

     

       1417
       1417
       -
                       #derives

     

       1418
       1418
       -
                       #[serde(rename_all = "camelCase")]

     

       1419
       1419
       -
                       pub struct #ident<'a> {

     

       1420
       1420
       -
                           #(#fields)*

     

       1421
       1421
       -
                       }

     

       1422
       1422
       -
       

     

       1423
       1423
       -
                       //#into_static_impl

     

       1424
       1424
       -
                   })

     

       1425
       1425
       -
               } else {

     

       1426
       1426
       -
                   Ok(quote! {

     

       1427
       1427
       -
                       #(#default_fns)*

     

       1428
       1428
       -
       

     

       1429
       1429
       -
                       #doc

     

       1430
       1430
       -
                       #derives

     

       1431
       1431
       -
                       #[serde(rename_all = "camelCase")]

     

       1432
       1432
       -
                       pub struct #ident {

     

       1433
       1433
       -
                           #(#fields)*

     

       1434
       1434
       -
                       }

     

       1435
       1435
       -
       

     

       1436
       1436
       -
                       //#into_static_impl

     

       1437
       1437
       -
                   })

     

       1438
       1438
       -
               }

     

       1439
       1439
       -
           }

     

       1440
       1440
       -
       

     

       1441
       1441
       -
           /// Generate param field with serde default if present

     

       1442
       1442
       -
           /// Returns (field_tokens, optional_default_function)

     

       1443
       1443
       -
           fn generate_param_field_with_default(

     

       1444
       1444
       -
               &self,

     

       1445
       1445
       -
               nsid: &str,

     

       1446
       1446
       -
               field_name: &str,

     

       1447
       1447
       -
               field_type: &crate::lexicon::LexXrpcParametersProperty<'static>,

     

       1448
       1448
       -
               is_required: bool,

     

       1449
       1449
       -
           ) -> Result<(TokenStream, Option<TokenStream>)> {

     

       1450
       1450
       -
               use crate::lexicon::LexXrpcParametersProperty;

     

       1451
       1451
       -
               use heck::ToSnakeCase;

     

       1452
       1452
       -
       

     

       1453
       1453
       -
               // Get base field

     

       1454
       1454
       -
               let base_field = self.generate_param_field(nsid, field_name, field_type, is_required)?;

     

       1455
       1455
       -
       

     

       1456
       1456
       -
               // Generate default function and attribute for required fields with defaults

     

       1457
       1457
       -
               // For optional fields, just add doc comments

     

       1458
       1458
       -
               let (doc_comment, serde_attr, default_fn) = if is_required {

     

       1459
       1459
       -
                   match field_type {

     

       1460
       1460
       -
                       LexXrpcParametersProperty::Boolean(b) if b.default.is_some() => {

     

       1461
       1461
       -
                           let v = b.default.unwrap();

     

       1462
       1462
       -
                           let fn_name = format!("_default_{}", field_name.to_snake_case());

     

       1463
       1463
       -
                           let fn_ident = syn::Ident::new(&fn_name, proc_macro2::Span::call_site());

     

       1464
       1464
       -
                           (

     

       1465
       1465
       -
                               Some(format!("Defaults to `{}`", v)),

     

       1466
       1466
       -
                               Some(quote! { #[serde(default = #fn_name)] }),

     

       1467
       1467
       -
                               Some(quote! {

     

       1468
       1468
       -
                                   fn #fn_ident() -> bool { #v }

     

       1469
       1469
       -
                               }),

     

       1470
       1470
       -
                           )

     

       1471
       1471
       -
                       }

     

       1472
       1472
       -
                       LexXrpcParametersProperty::Integer(i) if i.default.is_some() => {

     

       1473
       1473
       -
                           let v = i.default.unwrap();

     

       1474
       1474
       -
                           let fn_name = format!("_default_{}", field_name.to_snake_case());

     

       1475
       1475
       -
                           let fn_ident = syn::Ident::new(&fn_name, proc_macro2::Span::call_site());

     

       1476
       1476
       -
                           (

     

       1477
       1477
       -
                               Some(format!("Defaults to `{}`", v)),

     

       1478
       1478
       -
                               Some(quote! { #[serde(default = #fn_name)] }),

     

       1479
       1479
       -
                               Some(quote! {

     

       1480
       1480
       -
                                   fn #fn_ident() -> i64 { #v }

     

       1481
       1481
       -
                               }),

     

       1482
       1482
       -
                           )

     

       1483
       1483
       -
                       }

     

       1484
       1484
       -
                       LexXrpcParametersProperty::String(s) if s.default.is_some() => {

     

       1485
       1485
       -
                           let v = s.default.as_ref().unwrap().as_ref();

     

       1486
       1486
       -
                           let fn_name = format!("_default_{}", field_name.to_snake_case());

     

       1487
       1487
       -
                           let fn_ident = syn::Ident::new(&fn_name, proc_macro2::Span::call_site());

     

       1488
       1488
       -
                           (

     

       1489
       1489
       -
                               Some(format!("Defaults to `\"{}\"`", v)),

     

       1490
       1490
       -
                               Some(quote! { #[serde(default = #fn_name)] }),

     

       1491
       1491
       -
                               Some(quote! {

     

       1492
       1492
       -
                                   fn #fn_ident() -> jacquard_common::CowStr<'static> {

     

       1493
       1493
       -
                                       jacquard_common::CowStr::from(#v)

     

       1494
       1494
       -
                                   }

     

       1495
       1495
       -
                               }),

     

       1496
       1496
       -
                           )

     

       1497
       1497
       -
                       }

     

       1498
       1498
       -
                       _ => (None, None, None),

     

       1499
       1499
       -
                   }

     

       1500
       1500
       -
               } else {

     

       1501
       1501
       -
                   // Optional fields - just doc comments, no serde defaults

     

       1502
       1502
       -
                   let doc = match field_type {

     

       1503
       1503
       -
                       LexXrpcParametersProperty::Integer(i) => {

     

       1504
       1504
       -
                           let mut parts = Vec::new();

     

       1505
       1505
       -
                           if let Some(def) = i.default {

     

       1506
       1506
       -
                               parts.push(format!("default: {}", def));

     

       1507
       1507
       -
                           }

     

       1508
       1508
       -
                           if let Some(min) = i.minimum {

     

       1509
       1509
       -
                               parts.push(format!("min: {}", min));

     

       1510
       1510
       -
                           }

     

       1511
       1511
       -
                           if let Some(max) = i.maximum {

     

       1512
       1512
       -
                               parts.push(format!("max: {}", max));

     

       1513
       1513
       -
                           }

     

       1514
       1514
       -
                           if !parts.is_empty() {

     

       1515
       1515
       -
                               Some(format!("({})", parts.join(", ")))

     

       1516
       1516
       -
                           } else {

     

       1517
       1517
       -
                               None

     

       1518
       1518
       -
                           }

     

       1519
       1519
       -
                       }

     

       1520
       1520
       -
                       LexXrpcParametersProperty::String(s) => {

     

       1521
       1521
       -
                           let mut parts = Vec::new();

     

       1522
       1522
       -
                           if let Some(def) = s.default.as_ref() {

     

       1523
       1523
       -
                               parts.push(format!("default: \"{}\"", def.as_ref()));

     

       1524
       1524
       -
                           }

     

       1525
       1525
       -
                           if let Some(min) = s.min_length {

     

       1526
       1526
       -
                               parts.push(format!("min length: {}", min));

     

       1527
       1527
       -
                           }

     

       1528
       1528
       -
                           if let Some(max) = s.max_length {

     

       1529
       1529
       -
                               parts.push(format!("max length: {}", max));

     

       1530
       1530
       -
                           }

     

       1531
       1531
       -
                           if !parts.is_empty() {

     

       1532
       1532
       -
                               Some(format!("({})", parts.join(", ")))

     

       1533
       1533
       -
                           } else {

     

       1534
       1534
       -
                               None

     

       1535
       1535
       -
                           }

     

       1536
       1536
       -
                       }

     

       1537
       1537
       -
                       LexXrpcParametersProperty::Boolean(b) => {

     

       1538
       1538
       -
                           b.default.map(|v| format!("(default: {})", v))

     

       1539
       1539
       -
                       }

     

       1540
       1540
       -
                       _ => None,

     

       1541
       1541
       -
                   };

     

       1542
       1542
       -
                   (doc, None, None)

     

       1543
       1543
       -
               };

     

       1544
       1544
       -
       

     

       1545
       1545
       -
               let doc = doc_comment.as_ref().map(|d| quote! { #[doc = #d] });

     

       1546
       1546
       -
               let field_with_attrs = match (doc, serde_attr) {

     

       1547
       1547
       -
                   (Some(doc), Some(attr)) => quote! {

     

       1548
       1548
       -
                       #doc

     

       1549
       1549
       -
                       #attr

     

       1550
       1550
       -
                       #base_field

     

       1551
       1551
       -
                   },

     

       1552
       1552
       -
                   (Some(doc), None) => quote! {

     

       1553
       1553
       -
                       #doc

     

       1554
       1554
       -
                       #base_field

     

       1555
       1555
       -
                   },

     

       1556
       1556
       -
                   (None, Some(attr)) => quote! {

     

       1557
       1557
       -
                       #attr

     

       1558
       1558
       -
                       #base_field

     

       1559
       1559
       -
                   },

     

       1560
       1560
       -
                   (None, None) => base_field,

     

       1561
       1561
       -
               };

     

       1562
       1562
       -
       

     

       1563
       1563
       -
               Ok((field_with_attrs, default_fn))

     

       1564
       1564
       -
           }

     

       1565
       1565
       -
       

     

       1566
       1566
       -
           /// Generate input struct from XRPC body

     

       1567
       1567
       -
           fn generate_input_struct(

     

       1568
       1568
       -
               &self,

     

       1569
       1569
       -
               nsid: &str,

     

       1570
       1570
       -
               type_base: &str,

     

       1571
       1571
       -
               body: &LexXrpcBody<'static>,

     

       1572
       1572
       -
           ) -> Result<TokenStream> {

     

       1573
       1573
       -
               let ident = syn::Ident::new(type_base, proc_macro2::Span::call_site());

     

       1574
       1574
       -
       

     

       1575
       1575
       -
               // Check if this is a binary body (no schema, just raw bytes)

     

       1576
       1576
       -
               let is_binary_body = body.schema.is_none();

     

       1577
       1577
       -
       

     

       1578
       1578
       -
               let fields = if let Some(schema) = &body.schema {

     

       1579
       1579
       -
                   self.generate_body_fields("", type_base, schema, true)?

     

       1580
       1580
       -
               } else {

     

       1581
       1581
       -
                   // Binary body: just a bytes field

     

       1582
       1582
       -
                   quote! {

     

       1583
       1583
       -
                       pub body: bytes::Bytes,

     

       1584
       1584
       -
                   }

     

       1585
       1585
       -
               };

     

       1586
       1586
       -
       

     

       1587
       1587
       -
               let doc = self.generate_doc_comment(body.description.as_ref());

     

       1588
       1588
       -
       

     

       1589
       1589
       -
               // Binary bodies don't need #[lexicon] attribute or lifetime

     

       1590
       1590
       -
               let struct_def = if is_binary_body {

     

       1591
       1591
       -
                   quote! {

     

       1592
       1592
       -
                       #doc

     

       1593
       1593
       -
                       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder, jacquard_derive::IntoStatic)]

     

       1594
       1594
       -
                       #[builder(start_fn = new)]

     

       1595
       1595
       -
                       #[serde(rename_all = "camelCase")]

     

       1596
       1596
       -
                       pub struct #ident {

     

       1597
       1597
       -
                           #fields

     

       1598
       1598
       -
                       }

     

       1599
       1599
       -
                   }

     

       1600
       1600
       -
               } else {

     

       1601
       1601
       -
                   // Input structs with schemas: manually add extra_data field with #[builder(default)]

     

       1602
       1602
       -
                   // for bon compatibility. The #[lexicon] macro will see it exists and skip adding it.

     

       1603
       1603
       -
                   quote! {

     

       1604
       1604
       -
                       #doc

     

       1605
       1605
       -
                       #[jacquard_derive::lexicon]

     

       1606
       1606
       -
                       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder, jacquard_derive::IntoStatic)]

     

       1607
       1607
       -
                       #[serde(rename_all = "camelCase")]

     

       1608
       1608
       -
                       #[builder(start_fn = new)]

     

       1609
       1609
       -
                       pub struct #ident<'a> {

     

       1610
       1610
       -
                           #fields

     

       1611
       1611
       -
                           #[serde(flatten)]

     

       1612
       1612
       -
                           #[serde(borrow)]

     

       1613
       1613
       -
                           #[builder(default)]

     

       1614
       1614
       -
                           pub extra_data: ::std::collections::BTreeMap<

     

       1615
       1615
       -
                               ::jacquard_common::smol_str::SmolStr,

     

       1616
       1616
       -
                               ::jacquard_common::types::value::Data<'a>

     

       1617
       1617
       -
                           >,

     

       1618
       1618
       -
                       }

     

       1619
       1619
       -
                   }

     

       1620
       1620
       -
               };

     

       1621
       1621
       -
       

     

       1622
       1622
       -
               // Generate union types if schema is an Object

     

       1623
       1623
       -
               let mut unions = Vec::new();

     

       1624
       1624
       -
               if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema {

     

       1625
       1625
       -
                   for (field_name, field_type) in &obj.properties {

     

       1626
       1626
       -
                       if let LexObjectProperty::Union(union) = field_type {

     

       1627
       1627
       -
                           let union_name = format!("{}Record{}", type_base, field_name.to_pascal_case());

     

       1628
       1628
       -
                           let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       1629
       1629
       -
                           let union_def =

     

       1630
       1630
       -
                               self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       1631
       1631
       -
                           unions.push(union_def);

     

       1632
       1632
       -
                       }

     

       1633
       1633
       -
                   }

     

       1634
       1634
       -
               }

     

       1635
       1635
       -
       

     

       1636
       1636
       -
               // Generate IntoStatic impl

     

       1637
       1637
       -
               // let into_static_impl = if is_binary_body {

     

       1638
       1638
       -
               //     // Binary bodies: simple clone of the Bytes field

     

       1639
       1639
       -
               //     quote! {

     

       1640
       1640
       -
               //         impl jacquard_common::IntoStatic for #ident {

     

       1641
       1641
       -
               //             type Output = #ident;

     

       1642
       1642
       -
               //             fn into_static(self) -> Self::Output {

     

       1643
       1643
       -
               //                 self

     

       1644
       1644
       -
               //             }

     

       1645
       1645
       -
               //         }

     

       1646
       1646
       -
               //     }

     

       1647
       1647
       -
               // } else {

     

       1648
       1648
       -
               //     let field_names: Vec<&str> = match &body.schema {

     

       1649
       1649
       -
               //         Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) => {

     

       1650
       1650
       -
               //             obj.properties.keys().map(|k| k.as_str()).collect()

     

       1651
       1651
       -
               //         }

     

       1652
       1652
       -
               //         Some(_) => {

     

       1653
       1653
       -
               //             // For Ref or Union schemas, there's just a single flattened field

     

       1654
       1654
       -
               //             vec!["value"]

     

       1655
       1655
       -
               //         }

     

       1656
       1656
       -
               //         None => {

     

       1657
       1657
       -
               //             // No schema means no fields, just extra_data

     

       1658
       1658
       -
               //             vec![]

     

       1659
       1659
       -
               //         }

     

       1660
       1660
       -
               //     };

     

       1661
       1661
       -
               //     self.generate_into_static_for_struct(type_base, &field_names, true, true)

     

       1662
       1662
       -
               // };

     

       1663
       1663
       -
       

     

       1664
       1664
       -
               Ok(quote! {

     

       1665
       1665
       -
                   #struct_def

     

       1666
       1666
       -
                   #(#unions)*

     

       1667
       1667
       -
                   //#into_static_impl

     

       1668
       1668
       -
               })

     

       1669
       1669
       -
           }

     

       1670
       1670
       -
       

     

       1671
       1671
       -
           /// Generate output struct from XRPC body

     

       1672
       1672
       -
           fn generate_output_struct(

     

       1673
       1673
       -
               &self,

     

       1674
       1674
       -
               nsid: &str,

     

       1675
       1675
       -
               type_base: &str,

     

       1676
       1676
       -
               body: &LexXrpcBody<'static>,

     

       1677
       1677
       -
           ) -> Result<TokenStream> {

     

       1678
       1678
       -
               let struct_name = format!("{}Output", type_base);

     

       1679
       1679
       -
               let ident = syn::Ident::new(&struct_name, proc_macro2::Span::call_site());

     

       1680
       1680
       -
       

     

       1681
       1681
       -
               let fields = if let Some(schema) = &body.schema {

     

       1682
       1682
       -
                   self.generate_body_fields("", &struct_name, schema, false)?

     

       1683
       1683
       -
               } else {

     

       1684
       1684
       -
                   quote! {}

     

       1685
       1685
       -
               };

     

       1686
       1686
       -
       

     

       1687
       1687
       -
               let doc = self.generate_doc_comment(body.description.as_ref());

     

       1688
       1688
       -
       

     

       1689
       1689
       -
               // Output structs always get a lifetime since they have the #[lexicon] attribute

     

       1690
       1690
       -
               // which adds extra_data: BTreeMap<..., Data<'a>>

     

       1691
       1691
       -
               let struct_def = quote! {

     

       1692
       1692
       -
                   #doc

     

       1693
       1693
       -
                   #[jacquard_derive::lexicon]

     

       1694
       1694
       -
                   #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       1695
       1695
       -
                   #[serde(rename_all = "camelCase")]

     

       1696
       1696
       -
                   pub struct #ident<'a> {

     

       1697
       1697
       -
                       #fields

     

       1698
       1698
       -
                   }

     

       1699
       1699
       -
               };

     

       1700
       1700
       -
       

     

       1701
       1701
       -
               // Generate union types if schema is an Object

     

       1702
       1702
       -
               let mut unions = Vec::new();

     

       1703
       1703
       -
               if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema {

     

       1704
       1704
       -
                   for (field_name, field_type) in &obj.properties {

     

       1705
       1705
       -
                       if let LexObjectProperty::Union(union) = field_type {

     

       1706
       1706
       -
                           let union_name =

     

       1707
       1707
       -
                               format!("{}Record{}", struct_name, field_name.to_pascal_case());

     

       1708
       1708
       -
                           let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       1709
       1709
       -
                           let union_def =

     

       1710
       1710
       -
                               self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       1711
       1711
       -
                           unions.push(union_def);

     

       1712
       1712
       -
                       }

     

       1713
       1713
       -
                   }

     

       1714
       1714
       -
               }

     

       1715
       1715
       -
       

     

       1716
       1716
       -
               // Generate IntoStatic impl

     

       1717
       1717
       -
               // let field_names: Vec<&str> = match &body.schema {

     

       1718
       1718
       -
               //     Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) => {

     

       1719
       1719
       -
               //         obj.properties.keys().map(|k| k.as_str()).collect()

     

       1720
       1720
       -
               //     }

     

       1721
       1721
       -
               //     Some(_) => {

     

       1722
       1722
       -
               //         // For Ref or Union schemas, there's just a single flattened field

     

       1723
       1723
       -
               //         vec!["value"]

     

       1724
       1724
       -
               //     }

     

       1725
       1725
       -
               //     None => {

     

       1726
       1726
       -
               //         // No schema means no fields, just extra_data

     

       1727
       1727
       -
               //         vec![]

     

       1728
       1728
       -
               //     }

     

       1729
       1729
       -
               // };

     

       1730
       1730
       -
               // let into_static_impl =

     

       1731
       1731
       -
               //     self.generate_into_static_for_struct(&struct_name, &field_names, true, true);

     

       1732
       1732
       -
       

     

       1733
       1733
       -
               Ok(quote! {

     

       1734
       1734
       -
                   #struct_def

     

       1735
       1735
       -
                   #(#unions)*

     

       1736
       1736
       -
                   //#into_static_impl

     

       1737
       1737
       -
               })

     

       1738
       1738
       -
           }

     

       1739
       1739
       -
       

     

       1740
       1740
       -
           /// Generate fields from XRPC body schema

     

       1741
       1741
       -
           fn generate_body_fields(

     

       1742
       1742
       -
               &self,

     

       1743
       1743
       -
               nsid: &str,

     

       1744
       1744
       -
               parent_type_name: &str,

     

       1745
       1745
       -
               schema: &LexXrpcBodySchema<'static>,

     

       1746
       1746
       -
               is_builder: bool,

     

       1747
       1747
       -
           ) -> Result<TokenStream> {

     

       1748
       1748
       -
               use crate::lexicon::LexXrpcBodySchema;

     

       1749
       1749
       -
       

     

       1750
       1750
       -
               match schema {

     

       1751
       1751
       -
                   LexXrpcBodySchema::Object(obj) => {

     

       1752
       1752
       -
                       self.generate_object_fields(nsid, parent_type_name, obj, is_builder)

     

       1753
       1753
       -
                   }

     

       1754
       1754
       -
                   LexXrpcBodySchema::Ref(ref_type) => {

     

       1755
       1755
       -
                       let rust_type = self.ref_to_rust_type(&ref_type.r#ref)?;

     

       1756
       1756
       -
                       Ok(quote! {

     

       1757
       1757
       -
                           #[serde(flatten)]

     

       1758
       1758
       -
                           #[serde(borrow)]

     

       1759
       1759
       -
                           pub value: #rust_type,

     

       1760
       1760
       -
                       })

     

       1761
       1761
       -
                   }

     

       1762
       1762
       -
                   LexXrpcBodySchema::Union(_union) => {

     

       1763
       1763
       -
                       let rust_type = quote! { jacquard_common::types::value::Data<'a> };

     

       1764
       1764
       -
                       Ok(quote! {

     

       1765
       1765
       -
                           #[serde(flatten)]

     

       1766
       1766
       -
                           #[serde(borrow)]

     

       1767
       1767
       -
                           pub value: #rust_type,

     

       1768
       1768
       -
                       })

     

       1769
       1769
       -
                   }

     

       1770
       1770
       -
               }

     

       1771
       1771
       -
           }

     

       1772
       1772
       -
       

     

       1773
       1773
       -
           /// Generate a field for XRPC parameters

     

       1774
       1774
       -
           fn generate_param_field(

     

       1775
       1775
       -
               &self,

     

       1776
       1776
       -
               _nsid: &str,

     

       1777
       1777
       -
               field_name: &str,

     

       1778
       1778
       -
               field_type: &crate::lexicon::LexXrpcParametersProperty<'static>,

     

       1779
       1779
       -
               is_required: bool,

     

       1780
       1780
       -
           ) -> Result<TokenStream> {

     

       1781
       1781
       -
               use crate::lexicon::LexXrpcParametersProperty;

     

       1782
       1782
       -
       

     

       1783
       1783
       -
               let field_ident = make_ident(&field_name.to_snake_case());

     

       1784
       1784
       -
       

     

       1785
       1785
       -
               let (rust_type, needs_lifetime, is_cowstr) = match field_type {

     

       1786
       1786
       -
                   LexXrpcParametersProperty::Boolean(_) => (quote! { bool }, false, false),

     

       1787
       1787
       -
                   LexXrpcParametersProperty::Integer(_) => (quote! { i64 }, false, false),

     

       1788
       1788
       -
                   LexXrpcParametersProperty::String(s) => {

     

       1789
       1789
       -
                       let is_cowstr = s.format.is_none(); // CowStr for plain strings

     

       1790
       1790
       -
                       (

     

       1791
       1791
       -
                           self.string_to_rust_type(s),

     

       1792
       1792
       -
                           self.string_needs_lifetime(s),

     

       1793
       1793
       -
                           is_cowstr,

     

       1794
       1794
       -
                       )

     

       1795
       1795
       -
                   }

     

       1796
       1796
       -
                   LexXrpcParametersProperty::Unknown(_) => (

     

       1797
       1797
       -
                       quote! { jacquard_common::types::value::Data<'a> },

     

       1798
       1798
       -
                       true,

     

       1799
       1799
       -
                       false,

     

       1800
       1800
       -
                   ),

     

       1801
       1801
       -
                   LexXrpcParametersProperty::Array(arr) => {

     

       1802
       1802
       -
                       let needs_lifetime = match &arr.items {

     

       1803
       1803
       -
                           crate::lexicon::LexPrimitiveArrayItem::Boolean(_)

     

       1804
       1804
       -
                           | crate::lexicon::LexPrimitiveArrayItem::Integer(_) => false,

     

       1805
       1805
       -
                           crate::lexicon::LexPrimitiveArrayItem::String(s) => {

     

       1806
       1806
       -
                               self.string_needs_lifetime(s)

     

       1807
       1807
       -
                           }

     

       1808
       1808
       -
                           crate::lexicon::LexPrimitiveArrayItem::Unknown(_) => true,

     

       1809
       1809
       -
                       };

     

       1810
       1810
       -
                       let item_type = match &arr.items {

     

       1811
       1811
       -
                           crate::lexicon::LexPrimitiveArrayItem::Boolean(_) => quote! { bool },

     

       1812
       1812
       -
                           crate::lexicon::LexPrimitiveArrayItem::Integer(_) => quote! { i64 },

     

       1813
       1813
       -
                           crate::lexicon::LexPrimitiveArrayItem::String(s) => self.string_to_rust_type(s),

     

       1814
       1814
       -
                           crate::lexicon::LexPrimitiveArrayItem::Unknown(_) => {

     

       1815
       1815
       -
                               quote! { jacquard_common::types::value::Data<'a> }

     

       1816
       1816
       -
                           }

     

       1817
       1817
       -
                       };

     

       1818
       1818
       -
                       (quote! { Vec<#item_type> }, needs_lifetime, false)

     

       1819
       1819
       -
                   }

     

       1820
       1820
       -
               };

     

       1821
       1821
       -
       

     

       1822
       1822
       -
               let rust_type = if is_required {

     

       1823
       1823
       -
                   rust_type

     

       1824
       1824
       -
               } else {

     

       1825
       1825
       -
                   quote! { std::option::Option<#rust_type> }

     

       1826
       1826
       -
               };

     

       1827
       1827
       -
       

     

       1828
       1828
       -
               let mut attrs = Vec::new();

     

       1829
       1829
       -
       

     

       1830
       1830
       -
               if !is_required {

     

       1831
       1831
       -
                   attrs.push(quote! { #[serde(skip_serializing_if = "std::option::Option::is_none")] });

     

       1832
       1832
       -
               }

     

       1833
       1833
       -
       

     

       1834
       1834
       -
               // Add serde(borrow) to all fields with lifetimes

     

       1835
       1835
       -
               if needs_lifetime {

     

       1836
       1836
       -
                   attrs.push(quote! { #[serde(borrow)] });

     

       1837
       1837
       -
               }

     

       1838
       1838
       -
       

     

       1839
       1839
       -
               // Add builder(into) for CowStr fields to allow String, &str, etc.

     

       1840
       1840
       -
               if is_cowstr {

     

       1841
       1841
       -
                   attrs.push(quote! { #[builder(into)] });

     

       1842
       1842
       -
               }

     

       1843
       1843
       -
       

     

       1844
       1844
       -
               Ok(quote! {

     

       1845
       1845
       -
                   #(#attrs)*

     

       1846
       1846
       -
                   pub #field_ident: #rust_type,

     

       1847
       1847
       -
               })

     

       1848
       1848
       -
           }

     

       1849
       1849
       -
       

     

       1850
       1850
       -
           /// Generate error enum from XRPC errors

     

       1851
       1851
       -
           fn generate_error_enum(

     

       1852
       1852
       -
               &self,

     

       1853
       1853
       -
               type_base: &str,

     

       1854
       1854
       -
               errors: &[LexXrpcError<'static>],

     

       1855
       1855
       -
           ) -> Result<TokenStream> {

     

       1856
       1856
       -
               let enum_name = format!("{}Error", type_base);

     

       1857
       1857
       -
               let ident = syn::Ident::new(&enum_name, proc_macro2::Span::call_site());

     

       1858
       1858
       -
       

     

       1859
       1859
       -
               let mut variants = Vec::new();

     

       1860
       1860
       -
               let mut display_arms = Vec::new();

     

       1861
       1861
       -
       

     

       1862
       1862
       -
               for error in errors {

     

       1863
       1863
       -
                   let variant_name = error.name.to_pascal_case();

     

       1864
       1864
       -
                   let variant_ident = syn::Ident::new(&variant_name, proc_macro2::Span::call_site());

     

       1865
       1865
       -
       

     

       1866
       1866
       -
                   let error_name = error.name.as_ref();

     

       1867
       1867
       -
                   let doc = self.generate_doc_comment(error.description.as_ref());

     

       1868
       1868
       -
       

     

       1869
       1869
       -
                   variants.push(quote! {

     

       1870
       1870
       -
                       #doc

     

       1871
       1871
       -
                       #[serde(rename = #error_name)]

     

       1872
       1872
       -
                       #variant_ident(std::option::Option<String>)

     

       1873
       1873
       -
                   });

     

       1874
       1874
       -
       

     

       1875
       1875
       -
                   display_arms.push(quote! {

     

       1876
       1876
       -
                       Self::#variant_ident(msg) => {

     

       1877
       1877
       -
                           write!(f, #error_name)?;

     

       1878
       1878
       -
                           if let Some(msg) = msg {

     

       1879
       1879
       -
                               write!(f, ": {}", msg)?;

     

       1880
       1880
       -
                           }

     

       1881
       1881
       -
                           Ok(())

     

       1882
       1882
       -
                       }

     

       1883
       1883
       -
                   });

     

       1884
       1884
       -
               }

     

       1885
       1885
       -
       

     

       1886
       1886
       -
               // Generate IntoStatic impl

     

       1887
       1887
       -
               let variant_info: Vec<(String, EnumVariantKind)> = errors

     

       1888
       1888
       -
                   .iter()

     

       1889
       1889
       -
                   .map(|e| (e.name.to_pascal_case(), EnumVariantKind::Tuple))

     

       1890
       1890
       -
                   .collect();

     

       1891
       1891
       -
               let into_static_impl =

     

       1892
       1892
       -
                   self.generate_into_static_for_enum(&enum_name, &variant_info, true, true);

     

       1893
       1893
       -
       

     

       1894
       1894
       -
               Ok(quote! {

     

       1895
       1895
       -
                   #[jacquard_derive::open_union]

     

       1896
       1896
       -
                   #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, thiserror::Error, miette::Diagnostic)]

     

       1897
       1897
       -
                   #[serde(tag = "error", content = "message")]

     

       1898
       1898
       -
                   #[serde(bound(deserialize = "'de: 'a"))]

     

       1899
       1899
       -
                   pub enum #ident<'a> {

     

       1900
       1900
       -
                       #(#variants,)*

     

       1901
       1901
       -
                   }

     

       1902
       1902
       -
       

     

       1903
       1903
       -
                   impl std::fmt::Display for #ident<'_> {

     

       1904
       1904
       -
                       fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

     

       1905
       1905
       -
                           match self {

     

       1906
       1906
       -
                               #(#display_arms)*

     

       1907
       1907
       -
                               Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       1908
       1908
       -
                           }

     

       1909
       1909
       -
                       }

     

       1910
       1910
       -
                   }

     

       1911
       1911
       -
       

     

       1912
       1912
       -
                   #into_static_impl

     

       1913
       1913
       -
               })

     

       1914
       1914
       -
           }

     

       1915
       1915
       -
       

     

       1916
       1916
       -
           /// Generate enum for string with known values

     

       1917
       1917
       -
           fn generate_known_values_enum(

     

       1918
       1918
       -
               &self,

     

       1919
       1919
       -
               nsid: &str,

     

       1920
       1920
       -
               def_name: &str,

     

       1921
       1921
       -
               string: &LexString<'static>,

     

       1922
       1922
       -
           ) -> Result<TokenStream> {

     

       1923
       1923
       -
               let type_name = self.def_to_type_name(nsid, def_name);

     

       1924
       1924
       -
               let ident = syn::Ident::new(&type_name, proc_macro2::Span::call_site());

     

       1925
       1925
       -
       

     

       1926
       1926
       -
               let known_values = string.known_values.as_ref().unwrap();

     

       1927
       1927
       -
               let mut variants = Vec::new();

     

       1928
       1928
       -
               let mut from_str_arms = Vec::new();

     

       1929
       1929
       -
               let mut as_str_arms = Vec::new();

     

       1930
       1930
       -
       

     

       1931
       1931
       -
               for value in known_values {

     

       1932
       1932
       -
                   // Convert value to valid Rust identifier

     

       1933
       1933
       -
                   let value_str = value.as_ref();

     

       1934
       1934
       -
                   let variant_name = value_to_variant_name(value_str);

     

       1935
       1935
       -
                   let variant_ident = syn::Ident::new(&variant_name, proc_macro2::Span::call_site());

     

       1936
       1936
       -
       

     

       1937
       1937
       -
                   variants.push(quote! {

     

       1938
       1938
       -
                       #variant_ident

     

       1939
       1939
       -
                   });

     

       1940
       1940
       -
       

     

       1941
       1941
       -
                   from_str_arms.push(quote! {

     

       1942
       1942
       -
                       #value_str => Self::#variant_ident

     

       1943
       1943
       -
                   });

     

       1944
       1944
       -
       

     

       1945
       1945
       -
                   as_str_arms.push(quote! {

     

       1946
       1946
       -
                       Self::#variant_ident => #value_str

     

       1947
       1947
       -
                   });

     

       1948
       1948
       -
               }

     

       1949
       1949
       -
       

     

       1950
       1950
       -
               let doc = self.generate_doc_comment(string.description.as_ref());

     

       1951
       1951
       -
       

     

       1952
       1952
       -
               // Generate IntoStatic impl

     

       1953
       1953
       -
               let variant_info: Vec<(String, EnumVariantKind)> = known_values

     

       1954
       1954
       -
                   .iter()

     

       1955
       1955
       -
                   .map(|value| {

     

       1956
       1956
       -
                       let variant_name = value_to_variant_name(value.as_ref());

     

       1957
       1957
       -
                       (variant_name, EnumVariantKind::Unit)

     

       1958
       1958
       -
                   })

     

       1959
       1959
       -
                   .chain(std::iter::once((

     

       1960
       1960
       -
                       "Other".to_string(),

     

       1961
       1961
       -
                       EnumVariantKind::Tuple,

     

       1962
       1962
       -
                   )))

     

       1963
       1963
       -
                   .collect();

     

       1964
       1964
       -
               let into_static_impl =

     

       1965
       1965
       -
                   self.generate_into_static_for_enum(&type_name, &variant_info, true, false);

     

       1966
       1966
       -
       

     

       1967
       1967
       -
               Ok(quote! {

     

       1968
       1968
       -
                   #doc

     

       1969
       1969
       -
                   #[derive(Debug, Clone, PartialEq, Eq, Hash)]

     

       1970
       1970
       -
                   pub enum #ident<'a> {

     

       1971
       1971
       -
                       #(#variants,)*

     

       1972
       1972
       -
                       Other(jacquard_common::CowStr<'a>),

     

       1973
       1973
       -
                   }

     

       1974
       1974
       -
       

     

       1975
       1975
       -
                   impl<'a> #ident<'a> {

     

       1976
       1976
       -
                       pub fn as_str(&self) -> &str {

     

       1977
       1977
       -
                           match self {

     

       1978
       1978
       -
                               #(#as_str_arms,)*

     

       1979
       1979
       -
                               Self::Other(s) => s.as_ref(),

     

       1980
       1980
       -
                           }

     

       1981
       1981
       -
                       }

     

       1982
       1982
       -
                   }

     

       1983
       1983
       -
       

     

       1984
       1984
       -
                   impl<'a> From<&'a str> for #ident<'a> {

     

       1985
       1985
       -
                       fn from(s: &'a str) -> Self {

     

       1986
       1986
       -
                           match s {

     

       1987
       1987
       -
                               #(#from_str_arms,)*

     

       1988
       1988
       -
                               _ => Self::Other(jacquard_common::CowStr::from(s)),

     

       1989
       1989
       -
                           }

     

       1990
       1990
       -
                       }

     

       1991
       1991
       -
                   }

     

       1992
       1992
       -
       

     

       1993
       1993
       -
                   impl<'a> From<String> for #ident<'a> {

     

       1994
       1994
       -
                       fn from(s: String) -> Self {

     

       1995
       1995
       -
                           match s.as_str() {

     

       1996
       1996
       -
                               #(#from_str_arms,)*

     

       1997
       1997
       -
                               _ => Self::Other(jacquard_common::CowStr::from(s)),

     

       1998
       1998
       -
                           }

     

       1999
       1999
       -
                       }

     

       2000
       2000
       -
                   }

     

       2001
       2001
       -
       

     

       2002
       2002
       -
                   impl<'a> AsRef<str> for #ident<'a> {

     

       2003
       2003
       -
                       fn as_ref(&self) -> &str {

     

       2004
       2004
       -
                           self.as_str()

     

       2005
       2005
       -
                       }

     

       2006
       2006
       -
                   }

     

       2007
       2007
       -
       

     

       2008
       2008
       -
                   impl<'a> serde::Serialize for #ident<'a> {

     

       2009
       2009
       -
                       fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

     

       2010
       2010
       -
                       where

     

       2011
       2011
       -
                           S: serde::Serializer,

     

       2012
       2012
       -
                       {

     

       2013
       2013
       -
                           serializer.serialize_str(self.as_str())

     

       2014
       2014
       -
                       }

     

       2015
       2015
       -
                   }

     

       2016
       2016
       -
       

     

       2017
       2017
       -
                   impl<'de, 'a> serde::Deserialize<'de> for #ident<'a>

     

       2018
       2018
       -
                   where

     

       2019
       2019
       -
                       'de: 'a,

     

       2020
       2020
       -
                   {

     

       2021
       2021
       -
                       fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

     

       2022
       2022
       -
                       where

     

       2023
       2023
       -
                           D: serde::Deserializer<'de>,

     

       2024
       2024
       -
                       {

     

       2025
       2025
       -
                           let s = <&'de str>::deserialize(deserializer)?;

     

       2026
       2026
       -
                           Ok(Self::from(s))

     

       2027
       2027
       -
                       }

     

       2028
       2028
       -
                   }

     

       2029
       2029
       -
       

     

       2030
       2030
       -
                   #into_static_impl

     

       2031
       2031
       -
               })

     

       2032
       2032
       -
           }

     

       2033
       2033
       -
       

     

       2034
       2034
       -
           /// Generate enum for integer with enum values

     

       2035
       2035
       -
           fn generate_integer_enum(

     

       2036
       2036
       -
               &self,

     

       2037
       2037
       -
               nsid: &str,

     

       2038
       2038
       -
               def_name: &str,

     

       2039
       2039
       -
               integer: &LexInteger<'static>,

     

       2040
       2040
       -
           ) -> Result<TokenStream> {

     

       2041
       2041
       -
               let type_name = self.def_to_type_name(nsid, def_name);

     

       2042
       2042
       -
               let ident = syn::Ident::new(&type_name, proc_macro2::Span::call_site());

     

       2043
       2043
       -
       

     

       2044
       2044
       -
               let enum_values = integer.r#enum.as_ref().unwrap();

     

       2045
       2045
       -
               let mut variants = Vec::new();

     

       2046
       2046
       -
               let mut from_i64_arms = Vec::new();

     

       2047
       2047
       -
               let mut to_i64_arms = Vec::new();

     

       2048
       2048
       -
       

     

       2049
       2049
       -
               for value in enum_values {

     

       2050
       2050
       -
                   let variant_name = format!("Value{}", value.abs());

     

       2051
       2051
       -
                   let variant_ident = syn::Ident::new(&variant_name, proc_macro2::Span::call_site());

     

       2052
       2052
       -
       

     

       2053
       2053
       -
                   variants.push(quote! {

     

       2054
       2054
       -
                       #[serde(rename = #value)]

     

       2055
       2055
       -
                       #variant_ident

     

       2056
       2056
       -
                   });

     

       2057
       2057
       -
       

     

       2058
       2058
       -
                   from_i64_arms.push(quote! {

     

       2059
       2059
       -
                       #value => Self::#variant_ident

     

       2060
       2060
       -
                   });

     

       2061
       2061
       -
       

     

       2062
       2062
       -
                   to_i64_arms.push(quote! {

     

       2063
       2063
       -
                       Self::#variant_ident => #value

     

       2064
       2064
       -
                   });

     

       2065
       2065
       -
               }

     

       2066
       2066
       -
       

     

       2067
       2067
       -
               let doc = self.generate_doc_comment(integer.description.as_ref());

     

       2068
       2068
       -
       

     

       2069
       2069
       -
               Ok(quote! {

     

       2070
       2070
       -
                   #doc

     

       2071
       2071
       -
                   #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

     

       2072
       2072
       -
                   pub enum #ident {

     

       2073
       2073
       -
                       #(#variants,)*

     

       2074
       2074
       -
                       #[serde(untagged)]

     

       2075
       2075
       -
                       Other(i64),

     

       2076
       2076
       -
                   }

     

       2077
       2077
       -
       

     

       2078
       2078
       -
                   impl #ident {

     

       2079
       2079
       -
                       pub fn as_i64(&self) -> i64 {

     

       2080
       2080
       -
                           match self {

     

       2081
       2081
       -
                               #(#to_i64_arms,)*

     

       2082
       2082
       -
                               Self::Other(n) => *n,

     

       2083
       2083
       -
                           }

     

       2084
       2084
       -
                       }

     

       2085
       2085
       -
                   }

     

       2086
       2086
       -
       

     

       2087
       2087
       -
                   impl From<i64> for #ident {

     

       2088
       2088
       -
                       fn from(n: i64) -> Self {

     

       2089
       2089
       -
                           match n {

     

       2090
       2090
       -
                               #(#from_i64_arms,)*

     

       2091
       2091
       -
                               _ => Self::Other(n),

     

       2092
       2092
       -
                           }

     

       2093
       2093
       -
                       }

     

       2094
       2094
       -
                   }

     

       2095
       2095
       -
       

     

       2096
       2096
       -
                   impl serde::Serialize for #ident {

     

       2097
       2097
       -
                       fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

     

       2098
       2098
       -
                       where

     

       2099
       2099
       -
                           S: serde::Serializer,

     

       2100
       2100
       -
                       {

     

       2101
       2101
       -
                           serializer.serialize_i64(self.as_i64())

     

       2102
       2102
       -
                       }

     

       2103
       2103
       -
                   }

     

       2104
       2104
       -
       

     

       2105
       2105
       -
                   impl<'de> serde::Deserialize<'de> for #ident {

     

       2106
       2106
       -
                       fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

     

       2107
       2107
       -
                       where

     

       2108
       2108
       -
                           D: serde::Deserializer<'de>,

     

       2109
       2109
       -
                       {

     

       2110
       2110
       -
                           let n = i64::deserialize(deserializer)?;

     

       2111
       2111
       -
                           Ok(Self::from(n))

     

       2112
       2112
       -
                       }

     

       2113
       2113
       -
                   }

     

       2114
       2114
       -
               })

     

       2115
       2115
       -
           }

     

       2116
       2116
       -
       

     

       2117
       2117
       -
           /// Generate XrpcRequest trait impl for a query or procedure

     

       2118
       2118
       -
           fn generate_xrpc_request_impl(

     

       2119
       2119
       -
               &self,

     

       2120
       2120
       -
               nsid: &str,

     

       2121
       2121
       -
               type_base: &str,

     

       2122
       2122
       -
               method: TokenStream,

     

       2123
       2123
       -
               output_encoding: &str,

     

       2124
       2124
       -
               has_params: bool,

     

       2125
       2125
       -
               params_has_lifetime: bool,

     

       2126
       2126
       -
               has_output: bool,

     

       2127
       2127
       -
               has_errors: bool,

     

       2128
       2128
       -
               is_binary_input: bool,

     

       2129
       2129
       -
           ) -> Result<TokenStream> {

     

       2130
       2130
       -
               let output_type = if has_output {

     

       2131
       2131
       -
                   let output_ident = syn::Ident::new(

     

       2132
       2132
       -
                       &format!("{}Output", type_base),

     

       2133
       2133
       -
                       proc_macro2::Span::call_site(),

     

       2134
       2134
       -
                   );

     

       2135
       2135
       -
                   quote! { #output_ident<'de> }

     

       2136
       2136
       -
               } else {

     

       2137
       2137
       -
                   quote! { () }

     

       2138
       2138
       -
               };

     

       2139
       2139
       -
       

     

       2140
       2140
       -
               let error_type = if has_errors {

     

       2141
       2141
       -
                   let error_ident = syn::Ident::new(

     

       2142
       2142
       -
                       &format!("{}Error", type_base),

     

       2143
       2143
       -
                       proc_macro2::Span::call_site(),

     

       2144
       2144
       -
                   );

     

       2145
       2145
       -
                   quote! { #error_ident<'de> }

     

       2146
       2146
       -
               } else {

     

       2147
       2147
       -
                   quote! { jacquard_common::xrpc::GenericError<'de> }

     

       2148
       2148
       -
               };

     

       2149
       2149
       -
       

     

       2150
       2150
       -
               // Generate the response type that implements XrpcResp

     

       2151
       2151
       -
               let response_ident = syn::Ident::new(

     

       2152
       2152
       -
                   &format!("{}Response", type_base),

     

       2153
       2153
       -
                   proc_macro2::Span::call_site(),

     

       2154
       2154
       -
               );

     

       2155
       2155
       -
       

     

       2156
       2156
       -
               // Generate the endpoint type that implements XrpcEndpoint

     

       2157
       2157
       -
               let endpoint_ident = syn::Ident::new(

     

       2158
       2158
       -
                   &format!("{}Request", type_base),

     

       2159
       2159
       -
                   proc_macro2::Span::call_site(),

     

       2160
       2160
       -
               );

     

       2161
       2161
       -
       

     

       2162
       2162
       -
               let response_type = quote! {

     

       2163
       2163
       -
                   #[doc = "Response type for "]

     

       2164
       2164
       -
                   #[doc = #nsid]

     

       2165
       2165
       -
                   pub struct #response_ident;

     

       2166
       2166
       -
       

     

       2167
       2167
       -
                   impl jacquard_common::xrpc::XrpcResp for #response_ident {

     

       2168
       2168
       -
                       const NSID: &'static str = #nsid;

     

       2169
       2169
       -
                       const ENCODING: &'static str = #output_encoding;

     

       2170
       2170
       -
                       type Output<'de> = #output_type;

     

       2171
       2171
       -
                       type Err<'de> = #error_type;

     

       2172
       2172
       -
                   }

     

       2173
       2173
       -
               };

     

       2174
       2174
       -
       

     

       2175
       2175
       -
               // Generate encode_body() method for binary inputs

     

       2176
       2176
       -
               let encode_body_method = if is_binary_input {

     

       2177
       2177
       -
                   quote! {

     

       2178
       2178
       -
                       fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::xrpc::EncodeError> {

     

       2179
       2179
       -
                           Ok(self.body.to_vec())

     

       2180
       2180
       -
                       }

     

       2181
       2181
       -
                   }

     

       2182
       2182
       -
               } else {

     

       2183
       2183
       -
                   quote! {}

     

       2184
       2184
       -
               };

     

       2185
       2185
       -
       

     

       2186
       2186
       -
               // Generate decode_body() method for binary inputs

     

       2187
       2187
       -
               let decode_body_method = if is_binary_input {

     

       2188
       2188
       -
                   quote! {

     

       2189
       2189
       -
                       fn decode_body(

     

       2190
       2190
       -
                           body: &'de [u8],

     

       2191
       2191
       -
                       ) -> Result<Box<Self>, jacquard_common::error::DecodeError> {

     

       2192
       2192
       -
                           Ok(Box::new(Self {

     

       2193
       2193
       -
                               body: bytes::Bytes::copy_from_slice(body),

     

       2194
       2194
       -
                           }))

     

       2195
       2195
       -
                       }

     

       2196
       2196
       -
                   }

     

       2197
       2197
       -
               } else {

     

       2198
       2198
       -
                   quote! {}

     

       2199
       2199
       -
               };

     

       2200
       2200
       -
       

     

       2201
       2201
       -
               let endpoint_path = format!("/xrpc/{}", nsid);

     

       2202
       2202
       -
       

     

       2203
       2203
       -
               if has_params {

     

       2204
       2204
       -
                   // Implement on the params/input struct itself

     

       2205
       2205
       -
                   let request_ident = syn::Ident::new(type_base, proc_macro2::Span::call_site());

     

       2206
       2206
       -
                   let impl_target = if params_has_lifetime {

     

       2207
       2207
       -
                       quote! { #request_ident<'de> }

     

       2208
       2208
       -
                   } else {

     

       2209
       2209
       -
                       quote! { #request_ident }

     

       2210
       2210
       -
                   };

     

       2211
       2211
       -
       

     

       2212
       2212
       -
                   Ok(quote! {

     

       2213
       2213
       -
                       #response_type

     

       2214
       2214
       -
       

     

       2215
       2215
       -
                       impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for #impl_target {

     

       2216
       2216
       -
                           const NSID: &'static str = #nsid;

     

       2217
       2217
       -
                           const METHOD: jacquard_common::xrpc::XrpcMethod = #method;

     

       2218
       2218
       -
       

     

       2219
       2219
       -
                           type Response = #response_ident;

     

       2220
       2220
       -
       

     

       2221
       2221
       -
                           #encode_body_method

     

       2222
       2222
       -
                           #decode_body_method

     

       2223
       2223
       -
                       }

     

       2224
       2224
       -
       

     

       2225
       2225
       -
                       #[doc = "Endpoint type for "]

     

       2226
       2226
       -
                       #[doc = #nsid]

     

       2227
       2227
       -
                       pub struct #endpoint_ident;

     

       2228
       2228
       -
       

     

       2229
       2229
       -
                       impl jacquard_common::xrpc::XrpcEndpoint for #endpoint_ident {

     

       2230
       2230
       -
                           const PATH: &'static str = #endpoint_path;

     

       2231
       2231
       -
                           const METHOD: jacquard_common::xrpc::XrpcMethod = #method;

     

       2232
       2232
       -
       

     

       2233
       2233
       -
                           type Request<'de> = #impl_target;

     

       2234
       2234
       -
                           type Response = #response_ident;

     

       2235
       2235
       -
                       }

     

       2236
       2236
       -
                   })

     

       2237
       2237
       -
               } else {

     

       2238
       2238
       -
                   // No params - generate a marker struct

     

       2239
       2239
       -
                   let request_ident = syn::Ident::new(type_base, proc_macro2::Span::call_site());

     

       2240
       2240
       -
       

     

       2241
       2241
       -
                   Ok(quote! {

     

       2242
       2242
       -
                       /// XRPC request marker type

     

       2243
       2243
       -
                       #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, jacquard_derive::IntoStatic)]

     

       2244
       2244
       -
                       pub struct #request_ident;

     

       2245
       2245
       -
       

     

       2246
       2246
       -
                       #response_type

     

       2247
       2247
       -
       

     

       2248
       2248
       -
                       impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for #request_ident {

     

       2249
       2249
       -
                           const NSID: &'static str = #nsid;

     

       2250
       2250
       -
                           const METHOD: jacquard_common::xrpc::XrpcMethod = #method;

     

       2251
       2251
       -
       

     

       2252
       2252
       -
                           type Response = #response_ident;

     

       2253
       2253
       -
                       }

     

       2254
       2254
       -
       

     

       2255
       2255
       -
                       #[doc = "Endpoint type for "]

     

       2256
       2256
       -
                       #[doc = #nsid]

     

       2257
       2257
       -
                       pub struct #endpoint_ident;

     

       2258
       2258
       -
       

     

       2259
       2259
       -
                       impl jacquard_common::xrpc::XrpcEndpoint for #endpoint_ident {

     

       2260
       2260
       -
                           const PATH: &'static str = #endpoint_path;

     

       2261
       2261
       -
                           const METHOD: jacquard_common::xrpc::XrpcMethod = #method;

     

       2262
       2262
       -
       

     

       2263
       2263
       -
                           type Request<'de> = #request_ident;

     

       2264
       2264
       -
                           type Response = #response_ident;

     

       2265
       2265
       -
                       }

     

       2266
       2266
       -
                   })

     

       2267
       2267
       -
               }

     

       2268
       2268
       -
           }

     

       2269
       2269
       -
       

     

       2270
       2270
       -
           /// Generate a union enum

     

       2271
       2271
       -
           pub fn generate_union(

     

       2272
       2272
       -
               &self,

     

       2273
       2273
       -
               current_nsid: &str,

     

       2274
       2274
       -
               union_name: &str,

     

       2275
       2275
       -
               refs: &[jacquard_common::CowStr<'static>],

     

       2276
       2276
       -
               description: Option<&str>,

     

       2277
       2277
       -
               closed: Option<bool>,

     

       2278
       2278
       -
           ) -> Result<TokenStream> {

     

       2279
       2279
       -
               let enum_ident = syn::Ident::new(union_name, proc_macro2::Span::call_site());

     

       2280
       2280
       -
       

     

       2281
       2281
       -
               // Extract namespace prefix from current NSID (first two segments: "sh.weaver" from "sh.weaver.embed.recordWithMedia")

     

       2282
       2282
       -
               let parts: Vec<_> = current_nsid.splitn(3, '.').collect();

     

       2283
       2283
       -
               let current_namespace = if parts.len() >= 2 {

     

       2284
       2284
       -
                   format!("{}.{}", parts[0], parts[1])

     

       2285
       2285
       -
               } else {

     

       2286
       2286
       -
                   current_nsid.to_string()

     

       2287
       2287
       -
               };

     

       2288
       2288
       -
       

     

       2289
       2289
       -
               // First pass: collect all variant names and detect collisions

     

       2290
       2290
       -
               #[derive(Debug)]

     

       2291
       2291
       -
               struct VariantInfo<'a> {

     

       2292
       2292
       -
                   ref_str: &'a str,

     

       2293
       2293
       -
                   ref_nsid: &'a str,

     

       2294
       2294
       -
                   simple_name: String,

     

       2295
       2295
       -
                   is_current_namespace: bool,

     

       2296
       2296
       -
               }

     

       2297
       2297
       -
       

     

       2298
       2298
       -
               let mut variant_infos = Vec::new();

     

       2299
       2299
       -
               for ref_str in refs {

     

       2300
       2300
       -
                   // Parse ref to get NSID and def name

     

       2301
       2301
       -
                   let (ref_nsid, ref_def) = if let Some((nsid, fragment)) = ref_str.split_once('#') {

     

       2302
       2302
       -
                       (nsid, fragment)

     

       2303
       2303
       -
                   } else {

     

       2304
       2304
       -
                       (ref_str.as_ref(), "main")

     

       2305
       2305
       -
                   };

     

       2306
       2306
       -
       

     

       2307
       2307
       -
                   // Skip unknown refs - they'll be handled by Unknown variant

     

       2308
       2308
       -
                   if !self.corpus.ref_exists(ref_str.as_ref()) {

     

       2309
       2309
       -
                       continue;

     

       2310
       2310
       -
                   }

     

       2311
       2311
       -
       

     

       2312
       2312
       -
                   // Check if ref is in current namespace

     

       2313
       2313
       -
                   let is_current_namespace = ref_nsid.starts_with(&current_namespace);

     

       2314
       2314
       -
       

     

       2315
       2315
       -
                   // Generate simple variant name (without namespace prefix)

     

       2316
       2316
       -
                   let simple_name = if ref_def == "main" {

     

       2317
       2317
       -
                       ref_nsid.split('.').last().unwrap().to_pascal_case()

     

       2318
       2318
       -
                   } else {

     

       2319
       2319
       -
                       let last_segment = ref_nsid.split('.').last().unwrap().to_pascal_case();

     

       2320
       2320
       -
                       format!("{}{}", last_segment, ref_def.to_pascal_case())

     

       2321
       2321
       -
                   };

     

       2322
       2322
       -
       

     

       2323
       2323
       -
                   variant_infos.push(VariantInfo {

     

       2324
       2324
       -
                       ref_str: ref_str.as_ref(),

     

       2325
       2325
       -
                       ref_nsid,

     

       2326
       2326
       -
                       simple_name,

     

       2327
       2327
       -
                       is_current_namespace,

     

       2328
       2328
       -
                   });

     

       2329
       2329
       -
               }

     

       2330
       2330
       -
       

     

       2331
       2331
       -
               // Second pass: detect collisions and disambiguate

     

       2332
       2332
       -
               use std::collections::HashMap;

     

       2333
       2333
       -
               let mut name_counts: HashMap<String, usize> = HashMap::new();

     

       2334
       2334
       -
               for info in &variant_infos {

     

       2335
       2335
       -
                   *name_counts.entry(info.simple_name.clone()).or_insert(0) += 1;

     

       2336
       2336
       -
               }

     

       2337
       2337
       -
       

     

       2338
       2338
       -
               let mut variants = Vec::new();

     

       2339
       2339
       -
               for info in variant_infos {

     

       2340
       2340
       -
                   let has_collision = name_counts.get(&info.simple_name).copied().unwrap_or(0) > 1;

     

       2341
       2341
       -
       

     

       2342
       2342
       -
                   // Track namespace dependency for foreign refs

     

       2343
       2343
       -
                   if !info.is_current_namespace {

     

       2344
       2344
       -
                       let parts: Vec<_> = info.ref_nsid.splitn(3, '.').collect();

     

       2345
       2345
       -
                       let foreign_namespace = if parts.len() >= 2 {

     

       2346
       2346
       -
                           format!("{}.{}", parts[0], parts[1])

     

       2347
       2347
       -
                       } else {

     

       2348
       2348
       -
                           info.ref_nsid.to_string()

     

       2349
       2349
       -
                       };

     

       2350
       2350
       -
                       self.namespace_deps

     

       2351
       2351
       -
                           .borrow_mut()

     

       2352
       2352
       -
                           .entry(current_namespace.clone())

     

       2353
       2353
       -
                           .or_default()

     

       2354
       2354
       -
                           .insert(foreign_namespace);

     

       2355
       2355
       -
                   }

     

       2356
       2356
       -
       

     

       2357
       2357
       -
                   // Disambiguate: add second NSID segment prefix only to foreign refs when there's a collision

     

       2358
       2358
       -
                   let variant_name = if has_collision && !info.is_current_namespace {

     

       2359
       2359
       -
                       // Get second segment (namespace identifier: "bsky" from "app.bsky.embed.images")

     

       2360
       2360
       -
                       let segments: Vec<&str> = info.ref_nsid.split('.').collect();

     

       2361
       2361
       -
                       let prefix = if segments.len() >= 2 {

     

       2362
       2362
       -
                           segments[1].to_pascal_case()

     

       2363
       2363
       -
                       } else {

     

       2364
       2364
       -
                           // Fallback: use first segment if only one exists

     

       2365
       2365
       -
                           segments[0].to_pascal_case()

     

       2366
       2366
       -
                       };

     

       2367
       2367
       -
                       format!("{}{}", prefix, info.simple_name)

     

       2368
       2368
       -
                   } else {

     

       2369
       2369
       -
                       info.simple_name.clone()

     

       2370
       2370
       -
                   };

     

       2371
       2371
       -
       

     

       2372
       2372
       -
                   let variant_ident = syn::Ident::new(&variant_name, proc_macro2::Span::call_site());

     

       2373
       2373
       -
       

     

       2374
       2374
       -
                   // Get the Rust type for this ref

     

       2375
       2375
       -
                   let rust_type = self.ref_to_rust_type(info.ref_str)?;

     

       2376
       2376
       -
       

     

       2377
       2377
       -
                   // Add serde rename for the full NSID

     

       2378
       2378
       -
                   let ref_str_literal = info.ref_str;

     

       2379
       2379
       -
                   variants.push(quote! {

     

       2380
       2380
       -
                       #[serde(rename = #ref_str_literal)]

     

       2381
       2381
       -
                       #variant_ident(Box<#rust_type>)

     

       2382
       2382
       -
                   });

     

       2383
       2383
       -
               }

     

       2384
       2384
       -
       

     

       2385
       2385
       -
               let doc = description

     

       2386
       2386
       -
                   .map(|d| quote! { #[doc = #d] })

     

       2387
       2387
       -
                   .unwrap_or_else(|| quote! {});

     

       2388
       2388
       -
       

     

       2389
       2389
       -
               // Only add open_union if not closed

     

       2390
       2390
       -
               let is_open = closed != Some(true);

     

       2391
       2391
       -
       

     

       2392
       2392
       -
               // Generate IntoStatic impl

     

       2393
       2393
       -
               // let variant_info: Vec<(String, EnumVariantKind)> = refs

     

       2394
       2394
       -
               //     .iter()

     

       2395
       2395
       -
               //     .filter_map(|ref_str| {

     

       2396
       2396
       -
               //         // Skip unknown refs

     

       2397
       2397
       -
               //         if !self.corpus.ref_exists(ref_str.as_ref()) {

     

       2398
       2398
       -
               //             return None;

     

       2399
       2399
       -
               //         }

     

       2400
       2400
       -
       

     

       2401
       2401
       -
               //         let (ref_nsid, ref_def) = if let Some((nsid, fragment)) = ref_str.split_once('#') {

     

       2402
       2402
       -
               //             (nsid, fragment)

     

       2403
       2403
       -
               //         } else {

     

       2404
       2404
       -
               //             (ref_str.as_ref(), "main")

     

       2405
       2405
       -
               //         };

     

       2406
       2406
       -
       

     

       2407
       2407
       -
               //         let variant_name = if ref_def == "main" {

     

       2408
       2408
       -
               //             ref_nsid.split('.').last().unwrap().to_pascal_case()

     

       2409
       2409
       -
               //         } else {

     

       2410
       2410
       -
               //             let last_segment = ref_nsid.split('.').last().unwrap().to_pascal_case();

     

       2411
       2411
       -
               //             format!("{}{}", last_segment, ref_def.to_pascal_case())

     

       2412
       2412
       -
               //         };

     

       2413
       2413
       -
               //         Some((variant_name, EnumVariantKind::Tuple))

     

       2414
       2414
       -
               //     })

     

       2415
       2415
       -
               //     .collect();

     

       2416
       2416
       -
               // let into_static_impl =

     

       2417
       2417
       -
               //     self.generate_into_static_for_enum(union_name, &variant_info, true, is_open);

     

       2418
       2418
       -
       

     

       2419
       2419
       -
               if is_open {

     

       2420
       2420
       -
                   Ok(quote! {

     

       2421
       2421
       -
                       #doc

     

       2422
       2422
       -
                       #[jacquard_derive::open_union]

     

       2423
       2423
       -
                       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       2424
       2424
       -
                       #[serde(tag = "$type")]

     

       2425
       2425
       -
                       #[serde(bound(deserialize = "'de: 'a"))]

     

       2426
       2426
       -
                       pub enum #enum_ident<'a> {

     

       2427
       2427
       -
                           #(#variants,)*

     

       2428
       2428
       -
                       }

     

       2429
       2429
       -
       

     

       2430
       2430
       -
                       //#into_static_impl

     

       2431
       2431
       -
                   })

     

       2432
       2432
       -
               } else {

     

       2433
       2433
       -
                   Ok(quote! {

     

       2434
       2434
       -
                       #doc

     

       2435
       2435
       -
                       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       2436
       2436
       -
                       #[serde(tag = "$type")]

     

       2437
       2437
       -
                       #[serde(bound(deserialize = "'de: 'a"))]

     

       2438
       2438
       -
                       pub enum #enum_ident<'a> {

     

       2439
       2439
       -
                           #(#variants,)*

     

       2440
       2440
       -
                       }

     

       2441
       2441
       -
       

     

       2442
       2442
       -
                       //#into_static_impl

     

       2443
       2443
       -
                   })

     

       2444
       2444
       -
               }

     

       2445
       2445
       -
           }

     

       2446
       2446
       -
       

     

       2447
       2447
       -
           /// Generate IntoStatic impl for a struct

     

       2448
       2448
       -
           #[allow(dead_code)]

     

       2449
       2449
       -
           fn generate_into_static_for_struct(

     

       2450
       2450
       -
               &self,

     

       2451
       2451
       -
               type_name: &str,

     

       2452
       2452
       -
               field_names: &[&str],

     

       2453
       2453
       -
               has_lifetime: bool,

     

       2454
       2454
       -
               has_extra_data: bool,

     

       2455
       2455
       -
           ) -> TokenStream {

     

       2456
       2456
       -
               let ident = syn::Ident::new(type_name, proc_macro2::Span::call_site());

     

       2457
       2457
       -
       

     

       2458
       2458
       -
               let field_idents: Vec<_> = field_names

     

       2459
       2459
       -
                   .iter()

     

       2460
       2460
       -
                   .map(|name| make_ident(&name.to_snake_case()))

     

       2461
       2461
       -
                   .collect();

     

       2462
       2462
       -
       

     

       2463
       2463
       -
               if has_lifetime {

     

       2464
       2464
       -
                   let field_conversions: Vec<_> = field_idents

     

       2465
       2465
       -
                       .iter()

     

       2466
       2466
       -
                       .map(|field| quote! { #field: self.#field.into_static() })

     

       2467
       2467
       -
                       .collect();

     

       2468
       2468
       -
       

     

       2469
       2469
       -
                   let extra_data_conversion = if has_extra_data {

     

       2470
       2470
       -
                       quote! { extra_data: self.extra_data.into_static(), }

     

       2471
       2471
       -
                   } else {

     

       2472
       2472
       -
                       quote! {}

     

       2473
       2473
       -
                   };

     

       2474
       2474
       -
       

     

       2475
       2475
       -
                   quote! {

     

       2476
       2476
       -
                       impl jacquard_common::IntoStatic for #ident<'_> {

     

       2477
       2477
       -
                           type Output = #ident<'static>;

     

       2478
       2478
       -
       

     

       2479
       2479
       -
                           fn into_static(self) -> Self::Output {

     

       2480
       2480
       -
                               #ident {

     

       2481
       2481
       -
                                   #(#field_conversions,)*

     

       2482
       2482
       -
                                   #extra_data_conversion

     

       2483
       2483
       -
                               }

     

       2484
       2484
       -
                           }

     

       2485
       2485
       -
                       }

     

       2486
       2486
       -
                   }

     

       2487
       2487
       -
               } else {

     

       2488
       2488
       -
                   quote! {

     

       2489
       2489
       -
                       impl jacquard_common::IntoStatic for #ident {

     

       2490
       2490
       -
                           type Output = #ident;

     

       2491
       2491
       -
       

     

       2492
       2492
       -
                           fn into_static(self) -> Self::Output {

     

       2493
       2493
       -
                               self

     

       2494
       2494
       -
                           }

     

       2495
       2495
       -
                       }

     

       2496
       2496
       -
                   }

     

       2497
       2497
       -
               }

     

       2498
       2498
       -
           }

     

       2499
       2499
       -
       

     

       2500
       2500
       -
           /// Generate IntoStatic impl for an enum

     

       2501
       2501
       -
           fn generate_into_static_for_enum(

     

       2502
       2502
       -
               &self,

     

       2503
       2503
       -
               type_name: &str,

     

       2504
       2504
       -
               variant_info: &[(String, EnumVariantKind)],

     

       2505
       2505
       -
               has_lifetime: bool,

     

       2506
       2506
       -
               is_open: bool,

     

       2507
       2507
       -
           ) -> TokenStream {

     

       2508
       2508
       -
               let ident = syn::Ident::new(type_name, proc_macro2::Span::call_site());

     

       2509
       2509
       -
       

     

       2510
       2510
       -
               if has_lifetime {

     

       2511
       2511
       -
                   let variant_conversions: Vec<_> = variant_info

     

       2512
       2512
       -
                       .iter()

     

       2513
       2513
       -
                       .map(|(variant_name, kind)| {

     

       2514
       2514
       -
                           let variant_ident = syn::Ident::new(variant_name, proc_macro2::Span::call_site());

     

       2515
       2515
       -
                           match kind {

     

       2516
       2516
       -
                               EnumVariantKind::Unit => {

     

       2517
       2517
       -
                                   quote! {

     

       2518
       2518
       -
                                       #ident::#variant_ident => #ident::#variant_ident

     

       2519
       2519
       -
                                   }

     

       2520
       2520
       -
                               }

     

       2521
       2521
       -
                               EnumVariantKind::Tuple => {

     

       2522
       2522
       -
                                   quote! {

     

       2523
       2523
       -
                                       #ident::#variant_ident(v) => #ident::#variant_ident(v.into_static())

     

       2524
       2524
       -
                                   }

     

       2525
       2525
       -
                               }

     

       2526
       2526
       -
                               EnumVariantKind::Struct(fields) => {

     

       2527
       2527
       -
                                   let field_idents: Vec<_> = fields

     

       2528
       2528
       -
                                       .iter()

     

       2529
       2529
       -
                                       .map(|f| make_ident(&f.to_snake_case()))

     

       2530
       2530
       -
                                       .collect();

     

       2531
       2531
       -
                                   let field_conversions: Vec<_> = field_idents

     

       2532
       2532
       -
                                       .iter()

     

       2533
       2533
       -
                                       .map(|f| quote! { #f: #f.into_static() })

     

       2534
       2534
       -
                                       .collect();

     

       2535
       2535
       -
                                   quote! {

     

       2536
       2536
       -
                                       #ident::#variant_ident { #(#field_idents,)* } => #ident::#variant_ident {

     

       2537
       2537
       -
                                           #(#field_conversions,)*

     

       2538
       2538
       -
                                       }

     

       2539
       2539
       -
                                   }

     

       2540
       2540
       -
                               }

     

       2541
       2541
       -
                           }

     

       2542
       2542
       -
                       })

     

       2543
       2543
       -
                       .collect();

     

       2544
       2544
       -
       

     

       2545
       2545
       -
                   let unknown_conversion = if is_open {

     

       2546
       2546
       -
                       quote! {

     

       2547
       2547
       -
                           #ident::Unknown(v) => #ident::Unknown(v.into_static()),

     

       2548
       2548
       -
                       }

     

       2549
       2549
       -
                   } else {

     

       2550
       2550
       -
                       quote! {}

     

       2551
       2551
       -
                   };

     

       2552
       2552
       -
       

     

       2553
       2553
       -
                   quote! {

     

       2554
       2554
       -
                       impl jacquard_common::IntoStatic for #ident<'_> {

     

       2555
       2555
       -
                           type Output = #ident<'static>;

     

       2556
       2556
       -
       

     

       2557
       2557
       -
                           fn into_static(self) -> Self::Output {

     

       2558
       2558
       -
                               match self {

     

       2559
       2559
       -
                                   #(#variant_conversions,)*

     

       2560
       2560
       -
                                   #unknown_conversion

     

       2561
       2561
       -
                               }

     

       2562
       2562
       -
                           }

     

       2563
       2563
       -
                       }

     

       2564
       2564
       -
                   }

     

       2565
       2565
       -
               } else {

     

       2566
       2566
       -
                   quote! {

     

       2567
       2567
       -
                       impl jacquard_common::IntoStatic for #ident {

     

       2568
       2568
       -
                           type Output = #ident;

     

       2569
       2569
       -
       

     

       2570
       2570
       -
                           fn into_static(self) -> Self::Output {

     

       2571
       2571
       -
                               self

     

       2572
       2572
       -
                           }

     

       2573
       2573
       -
                       }

     

       2574
       2574
       -
                   }

     

       2575
       2575
       -
               }

     

       2576
       2576
       -
           }

     

       2577
       2577
       -
       

     

       2578
       2578
       -
           /// Get namespace dependencies collected during code generation

     

       2579
       2579
       -
           pub fn get_namespace_dependencies(

     

       2580
       2580
       -
               &self,

     

       2581
       2581
       -
           ) -> std::collections::HashMap<String, std::collections::HashSet<String>> {

     

       2582
       2582
       -
               self.namespace_deps.borrow().clone()

     

       2583
       2583
       -
           }

     

       2584
       2584
       -
       

     

       2585
       2585
       -
           /// Generate Cargo.toml features section from namespace dependencies

     

       2586
       2586
       -
           pub fn generate_cargo_features(&self, lib_rs_path: Option<&std::path::Path>) -> String {

     

       2587
       2587
       -
               use std::fmt::Write;

     

       2588
       2588
       -
       

     

       2589
       2589
       -
               let deps = self.namespace_deps.borrow();

     

       2590
       2590
       -
               let mut all_namespaces: std::collections::HashSet<String> =

     

       2591
       2591
       -
                   std::collections::HashSet::new();

     

       2592
       2592
       -
       

     

       2593
       2593
       -
               // Collect all namespaces from the corpus (first two segments of each NSID)

     

       2594
       2594
       -
               for (nsid, _doc) in self.corpus.iter() {

     

       2595
       2595
       -
                   let parts: Vec<_> = nsid.as_str().splitn(3, '.').collect();

     

       2596
       2596
       -
                   let namespace = if parts.len() >= 2 {

     

       2597
       2597
       -
                       format!("{}.{}", parts[0], parts[1])

     

       2598
       2598
       -
                   } else {

     

       2599
       2599
       -
                       nsid.to_string()

     

       2600
       2600
       -
                   };

     

       2601
       2601
       -
                   all_namespaces.insert(namespace);

     

       2602
       2602
       -
               }

     

       2603
       2603
       -
       

     

       2604
       2604
       -
               // Also collect existing feature names from lib.rs

     

       2605
       2605
       -
               let mut existing_features = std::collections::HashSet::new();

     

       2606
       2606
       -
               if let Some(lib_rs) = lib_rs_path {

     

       2607
       2607
       -
                   if let Ok(content) = std::fs::read_to_string(lib_rs) {

     

       2608
       2608
       -
                       for line in content.lines() {

     

       2609
       2609
       -
                           if let Some(feature) = line

     

       2610
       2610
       -
                               .trim()

     

       2611
       2611
       -
                               .strip_prefix("#[cfg(feature = \"")

     

       2612
       2612
       -
                               .and_then(|s| s.strip_suffix("\")]"))

     

       2613
       2613
       -
                           {

     

       2614
       2614
       -
                               existing_features.insert(feature.to_string());

     

       2615
       2615
       -
                           }

     

       2616
       2616
       -
                       }

     

       2617
       2617
       -
                   }

     

       2618
       2618
       -
               }

     

       2619
       2619
       -
       

     

       2620
       2620
       -
               let mut output = String::new();

     

       2621
       2621
       -
               writeln!(&mut output, "# Generated namespace features").unwrap();

     

       2622
       2622
       -
       

     

       2623
       2623
       -
               // Convert namespace to feature name (matching module path sanitization)

     

       2624
       2624
       -
               let to_feature_name = |ns: &str| {

     

       2625
       2625
       -
                   ns.split('.')

     

       2626
       2626
       -
                       .map(|segment| {

     

       2627
       2627
       -
                           // Apply same sanitization as module names

     

       2628
       2628
       -
                           let mut result = segment.replace('-', "_");

     

       2629
       2629
       -
                           // Prefix with underscore if starts with digit

     

       2630
       2630
       -
                           if result.chars().next().map_or(false, |c| c.is_ascii_digit()) {

     

       2631
       2631
       -
                               result.insert(0, '_');

     

       2632
       2632
       -
                           }

     

       2633
       2633
       -
                           result

     

       2634
       2634
       -
                       })

     

       2635
       2635
       -
                       .collect::<Vec<_>>()

     

       2636
       2636
       -
                       .join("_")

     

       2637
       2637
       -
               };

     

       2638
       2638
       -
       

     

       2639
       2639
       -
               // Collect all feature names (from corpus + existing lib.rs)

     

       2640
       2640
       -
               let mut all_feature_names = std::collections::HashSet::new();

     

       2641
       2641
       -
               for ns in &all_namespaces {

     

       2642
       2642
       -
                   all_feature_names.insert(to_feature_name(ns));

     

       2643
       2643
       -
               }

     

       2644
       2644
       -
               all_feature_names.extend(existing_features);

     

       2645
       2645
       -
       

     

       2646
       2646
       -
               // Sort for consistent output

     

       2647
       2647
       -
               let mut feature_names: Vec<_> = all_feature_names.iter().collect();

     

       2648
       2648
       -
               feature_names.sort();

     

       2649
       2649
       -
       

     

       2650
       2650
       -
               // Map namespace to feature name for dependency lookup

     

       2651
       2651
       -
               let mut ns_to_feature: std::collections::HashMap<&str, String> =

     

       2652
       2652
       -
                   std::collections::HashMap::new();

     

       2653
       2653
       -
               for ns in &all_namespaces {

     

       2654
       2654
       -
                   ns_to_feature.insert(ns.as_str(), to_feature_name(ns));

     

       2655
       2655
       -
               }

     

       2656
       2656
       -
       

     

       2657
       2657
       -
               for feature_name in feature_names {

     

       2658
       2658
       -
                   // Find corresponding namespace for this feature (if any) to look up deps

     

       2659
       2659
       -
                   let feature_deps: Vec<String> = all_namespaces

     

       2660
       2660
       -
                       .iter()

     

       2661
       2661
       -
                       .find(|ns| to_feature_name(ns) == *feature_name)

     

       2662
       2662
       -
                       .and_then(|ns| deps.get(ns.as_str()))

     

       2663
       2663
       -
                       .map(|ns_deps| {

     

       2664
       2664
       -
                           let mut dep_features: Vec<_> = ns_deps

     

       2665
       2665
       -
                               .iter()

     

       2666
       2666
       -
                               .map(|d| format!("\"{}\"", to_feature_name(d)))

     

       2667
       2667
       -
                               .collect();

     

       2668
       2668
       -
                           dep_features.sort();

     

       2669
       2669
       -
                           dep_features

     

       2670
       2670
       -
                       })

     

       2671
       2671
       -
                       .unwrap_or_default();

     

       2672
       2672
       -
       

     

       2673
       2673
       -
                   if !feature_deps.is_empty() {

     

       2674
       2674
       -
                       writeln!(

     

       2675
       2675
       -
                           &mut output,

     

       2676
       2676
       -
                           "{} = [{}]",

     

       2677
       2677
       -
                           feature_name,

     

       2678
       2678
       -
                           feature_deps.join(", ")

     

       2679
       2679
       -
                       )

     

       2680
       2680
       -
                       .unwrap();

     

       2681
       2681
       -
                   } else {

     

       2682
       2682
       -
                       writeln!(&mut output, "{} = []", feature_name).unwrap();

     

       2683
       2683
       -
                   }

     

       2684
       2684
       -
               }

     

       2685
       2685
       -
       

     

       2686
       2686
       -
               output

     

       2687
       2687
       -
           }

     

       2688
       2688
       -
       }

     

       2689
       2689
       -
       

     

       2690
       2690
       -
       /// Enum variant kind for IntoStatic generation

     

       2691
       2691
       -
       #[derive(Debug, Clone)]

     

       2692
       2692
       -
       #[allow(dead_code)]

     

       2693
       2693
       -
       enum EnumVariantKind {

     

       2694
       2694
       -
           Unit,

     

       2695
       2695
       -
           Tuple,

     

       2696
       2696
       -
           Struct(Vec<String>),

     

       2697
       172
        
       }

     

       2698
       173
        
       

     

       2699
       174
        
       #[cfg(test)]

+114

crates/jacquard-lexicon/src/codegen/lifetime.rs

···

       1
       1
       +
       use super::CodeGenerator;

     

       2
       2
       +
       use crate::lexicon::{

     

       3
       3
       +
           LexArrayItem, LexObjectProperty, LexString, LexStringFormat, LexUserType,

     

       4
       4
       +
       };

     

       5
       5
       +
       

     

       6
       6
       +
       impl<'c> CodeGenerator<'c> {

     

       7
       7
       +
           /// Check if a property type needs a lifetime parameter

     

       8
       8
       +
           pub(super) fn property_needs_lifetime(&self, prop: &LexObjectProperty<'static>) -> bool {

     

       9
       9
       +
               match prop {

     

       10
       10
       +
                   LexObjectProperty::Boolean(_) | LexObjectProperty::Integer(_) => false,

     

       11
       11
       +
                   LexObjectProperty::String(s) => self.string_needs_lifetime(s),

     

       12
       12
       +
                   LexObjectProperty::Bytes(_) => false, // Bytes is owned

     

       13
       13
       +
                   LexObjectProperty::CidLink(_)

     

       14
       14
       +
                   | LexObjectProperty::Blob(_)

     

       15
       15
       +
                   | LexObjectProperty::Unknown(_) => true,

     

       16
       16
       +
                   LexObjectProperty::Array(array) => self.array_item_needs_lifetime(&array.items),

     

       17
       17
       +
                   LexObjectProperty::Object(_) => true, // Nested objects have lifetimes

     

       18
       18
       +
                   LexObjectProperty::Ref(ref_type) => {

     

       19
       19
       +
                       // Check if the ref target actually needs a lifetime

     

       20
       20
       +
                       self.ref_needs_lifetime(&ref_type.r#ref)

     

       21
       21
       +
                   }

     

       22
       22
       +
                   LexObjectProperty::Union(_) => true, // Unions generally have lifetimes

     

       23
       23
       +
               }

     

       24
       24
       +
           }

     

       25
       25
       +
       

     

       26
       26
       +
           /// Check if an array item type needs a lifetime parameter

     

       27
       27
       +
           pub(super) fn array_item_needs_lifetime(&self, item: &LexArrayItem) -> bool {

     

       28
       28
       +
               match item {

     

       29
       29
       +
                   LexArrayItem::Boolean(_) | LexArrayItem::Integer(_) => false,

     

       30
       30
       +
                   LexArrayItem::String(s) => self.string_needs_lifetime(s),

     

       31
       31
       +
                   LexArrayItem::Bytes(_) => false,

     

       32
       32
       +
                   LexArrayItem::CidLink(_) | LexArrayItem::Blob(_) | LexArrayItem::Unknown(_) => true,

     

       33
       33
       +
                   LexArrayItem::Object(_) => true, // Nested objects have lifetimes

     

       34
       34
       +
                   LexArrayItem::Ref(ref_type) => self.ref_needs_lifetime(&ref_type.r#ref),

     

       35
       35
       +
                   LexArrayItem::Union(_) => true,

     

       36
       36
       +
               }

     

       37
       37
       +
           }

     

       38
       38
       +
       

     

       39
       39
       +
           /// Check if a string type needs a lifetime parameter

     

       40
       40
       +
           pub(super) fn string_needs_lifetime(&self, s: &LexString) -> bool {

     

       41
       41
       +
               match s.format {

     

       42
       42
       +
                   Some(LexStringFormat::Datetime)

     

       43
       43
       +
                   | Some(LexStringFormat::Language)

     

       44
       44
       +
                   | Some(LexStringFormat::Tid) => false,

     

       45
       45
       +
                   _ => true, // Most string types borrow

     

       46
       46
       +
               }

     

       47
       47
       +
           }

     

       48
       48
       +
       

     

       49
       49
       +
           /// Check if a ref needs a lifetime parameter

     

       50
       50
       +
           pub(super) fn ref_needs_lifetime(&self, ref_str: &str) -> bool {

     

       51
       51
       +
               // Try to resolve the ref

     

       52
       52
       +
               if let Some((_doc, def)) = self.corpus.resolve_ref(ref_str) {

     

       53
       53
       +
                   self.def_needs_lifetime(def)

     

       54
       54
       +
               } else {

     

       55
       55
       +
                   // If we can't resolve it, assume it needs a lifetime (safe default)

     

       56
       56
       +
                   true

     

       57
       57
       +
               }

     

       58
       58
       +
           }

     

       59
       59
       +
       

     

       60
       60
       +
           /// Check if a lexicon def needs a lifetime parameter

     

       61
       61
       +
           pub(super) fn def_needs_lifetime(&self, def: &LexUserType<'static>) -> bool {

     

       62
       62
       +
               match def {

     

       63
       63
       +
                   // Records and Objects always have lifetimes now since they get #[lexicon] attribute

     

       64
       64
       +
                   LexUserType::Record(_) => true,

     

       65
       65
       +
                   LexUserType::Object(_) => true,

     

       66
       66
       +
                   LexUserType::Token(_) => false,

     

       67
       67
       +
                   LexUserType::String(s) => {

     

       68
       68
       +
                       // Check if it's a known values enum or a regular string

     

       69
       69
       +
                       if s.known_values.is_some() {

     

       70
       70
       +
                           // Known values enums have Other(CowStr<'a>) variant

     

       71
       71
       +
                           true

     

       72
       72
       +
                       } else {

     

       73
       73
       +
                           self.string_needs_lifetime(s)

     

       74
       74
       +
                       }

     

       75
       75
       +
                   }

     

       76
       76
       +
                   LexUserType::Integer(_) => false,

     

       77
       77
       +
                   LexUserType::Boolean(_) => false,

     

       78
       78
       +
                   LexUserType::Bytes(_) => false,

     

       79
       79
       +
                   LexUserType::CidLink(_) | LexUserType::Blob(_) | LexUserType::Unknown(_) => true,

     

       80
       80
       +
                   LexUserType::Array(array) => self.array_item_needs_lifetime(&array.items),

     

       81
       81
       +
                   LexUserType::XrpcQuery(_)

     

       82
       82
       +
                   | LexUserType::XrpcProcedure(_)

     

       83
       83
       +
                   | LexUserType::XrpcSubscription(_) => {

     

       84
       84
       +
                       // XRPC types generate multiple structs, not a single type we can reference

     

       85
       85
       +
                       // Shouldn't be referenced directly

     

       86
       86
       +
                       true

     

       87
       87
       +
                   }

     

       88
       88
       +
               }

     

       89
       89
       +
           }

     

       90
       90
       +
       

     

       91
       91
       +
           /// Check if xrpc params need a lifetime parameter

     

       92
       92
       +
           pub(super) fn params_need_lifetime(&self, params: &crate::lexicon::LexXrpcParameters<'static>) -> bool {

     

       93
       93
       +
               params.properties.values().any(|prop| {

     

       94
       94
       +
                   use crate::lexicon::LexXrpcParametersProperty;

     

       95
       95
       +
                   match prop {

     

       96
       96
       +
                       LexXrpcParametersProperty::Boolean(_) | LexXrpcParametersProperty::Integer(_) => {

     

       97
       97
       +
                           false

     

       98
       98
       +
                       }

     

       99
       99
       +
                       LexXrpcParametersProperty::String(s) => self.string_needs_lifetime(s),

     

       100
       100
       +
                       LexXrpcParametersProperty::Unknown(_) => true,

     

       101
       101
       +
                       LexXrpcParametersProperty::Array(arr) => {

     

       102
       102
       +
                           use crate::lexicon::LexPrimitiveArrayItem;

     

       103
       103
       +
                           match &arr.items {

     

       104
       104
       +
                               LexPrimitiveArrayItem::Boolean(_) | LexPrimitiveArrayItem::Integer(_) => {

     

       105
       105
       +
                                   false

     

       106
       106
       +
                               }

     

       107
       107
       +
                               LexPrimitiveArrayItem::String(s) => self.string_needs_lifetime(s),

     

       108
       108
       +
                               LexPrimitiveArrayItem::Unknown(_) => true,

     

       109
       109
       +
                           }

     

       110
       110
       +
                       }

     

       111
       111
       +
                   }

     

       112
       112
       +
               })

     

       113
       113
       +
           }

     

       114
       114
       +
       }

+132

crates/jacquard-lexicon/src/codegen/names.rs

···

       1
       1
       +
       use super::utils::sanitize_name;

     

       2
       2
       +
       use super::CodeGenerator;

     

       3
       3
       +
       use heck::{ToPascalCase, ToSnakeCase};

     

       4
       4
       +
       

     

       5
       5
       +
       impl<'c> CodeGenerator<'c> {

     

       6
       6
       +
           /// Check if a single-variant union is self-referential

     

       7
       7
       +
           pub(super) fn is_self_referential_union(

     

       8
       8
       +
               &self,

     

       9
       9
       +
               nsid: &str,

     

       10
       10
       +
               parent_type_name: &str,

     

       11
       11
       +
               union: &crate::lexicon::LexRefUnion,

     

       12
       12
       +
           ) -> bool {

     

       13
       13
       +
               if union.refs.len() != 1 {

     

       14
       14
       +
                   return false;

     

       15
       15
       +
               }

     

       16
       16
       +
       

     

       17
       17
       +
               let ref_str = if union.refs[0].starts_with('#') {

     

       18
       18
       +
                   format!("{}{}", nsid, union.refs[0])

     

       19
       19
       +
               } else {

     

       20
       20
       +
                   union.refs[0].to_string()

     

       21
       21
       +
               };

     

       22
       22
       +
       

     

       23
       23
       +
               let (ref_nsid, ref_def) = if let Some((nsid_part, fragment)) = ref_str.split_once('#') {

     

       24
       24
       +
                   (nsid_part, fragment)

     

       25
       25
       +
               } else {

     

       26
       26
       +
                   (ref_str.as_str(), "main")

     

       27
       27
       +
               };

     

       28
       28
       +
       

     

       29
       29
       +
               let ref_type_name = self.def_to_type_name(ref_nsid, ref_def);

     

       30
       30
       +
               ref_type_name == parent_type_name

     

       31
       31
       +
           }

     

       32
       32
       +
       

     

       33
       33
       +
           /// Helper to generate field-based type name with collision detection

     

       34
       34
       +
           pub(super) fn generate_field_type_name(

     

       35
       35
       +
               &self,

     

       36
       36
       +
               nsid: &str,

     

       37
       37
       +
               parent_type_name: &str,

     

       38
       38
       +
               field_name: &str,

     

       39
       39
       +
               suffix: &str, // "" for union/object, "Item" for array unions

     

       40
       40
       +
           ) -> String {

     

       41
       41
       +
               let base_name = format!("{}{}{}", parent_type_name, field_name.to_pascal_case(), suffix);

     

       42
       42
       +
       

     

       43
       43
       +
               // Check for collisions with lexicon defs

     

       44
       44
       +
               if let Some(doc) = self.corpus.get(nsid) {

     

       45
       45
       +
                   let def_names: std::collections::HashSet<String> = doc

     

       46
       46
       +
                       .defs

     

       47
       47
       +
                       .keys()

     

       48
       48
       +
                       .map(|name| self.def_to_type_name(nsid, name.as_ref()))

     

       49
       49
       +
                       .collect();

     

       50
       50
       +
       

     

       51
       51
       +
                   if def_names.contains(&base_name) {

     

       52
       52
       +
                       // Use "Union" suffix for union types, "Record" for objects

     

       53
       53
       +
                       let disambiguator = if suffix.is_empty() && !parent_type_name.is_empty() {

     

       54
       54
       +
                           "Union"

     

       55
       55
       +
                       } else {

     

       56
       56
       +
                           "Record"

     

       57
       57
       +
                       };

     

       58
       58
       +
                       return format!("{}{}{}{}", parent_type_name, disambiguator, field_name.to_pascal_case(), suffix);

     

       59
       59
       +
                   }

     

       60
       60
       +
               }

     

       61
       61
       +
       

     

       62
       62
       +
               base_name

     

       63
       63
       +
           }

     

       64
       64
       +
       

     

       65
       65
       +
           /// Convert lexicon def name to Rust type name

     

       66
       66
       +
           pub(super) fn def_to_type_name(&self, nsid: &str, def_name: &str) -> String {

     

       67
       67
       +
               if def_name == "main" {

     

       68
       68
       +
                   // Use last segment of NSID

     

       69
       69
       +
                   let base_name = nsid.split('.').last().unwrap().to_pascal_case();

     

       70
       70
       +
       

     

       71
       71
       +
                   // Check if any other def would collide with this name

     

       72
       72
       +
                   if let Some(doc) = self.corpus.get(nsid) {

     

       73
       73
       +
                       let has_collision = doc.defs.keys().any(|other_def| {

     

       74
       74
       +
                           let other_def_str: &str = other_def.as_ref();

     

       75
       75
       +
                           other_def_str != "main" && other_def_str.to_pascal_case() == base_name

     

       76
       76
       +
                       });

     

       77
       77
       +
       

     

       78
       78
       +
                       if has_collision {

     

       79
       79
       +
                           return format!("{}Record", base_name);

     

       80
       80
       +
                       }

     

       81
       81
       +
                   }

     

       82
       82
       +
       

     

       83
       83
       +
                   base_name

     

       84
       84
       +
               } else {

     

       85
       85
       +
                   def_name.to_pascal_case()

     

       86
       86
       +
               }

     

       87
       87
       +
           }

     

       88
       88
       +
       

     

       89
       89
       +
           /// Convert NSID to file path relative to output directory

     

       90
       90
       +
           ///

     

       91
       91
       +
           /// - `app.bsky.feed.post` → `app_bsky/feed/post.rs`

     

       92
       92
       +
           /// - `com.atproto.label.defs` → `com_atproto/label.rs` (defs go in parent)

     

       93
       93
       +
           pub(super) fn nsid_to_file_path(&self, nsid: &str) -> std::path::PathBuf {

     

       94
       94
       +
               let parts: Vec<&str> = nsid.split('.').collect();

     

       95
       95
       +
       

     

       96
       96
       +
               if parts.len() < 2 {

     

       97
       97
       +
                   // Shouldn't happen with valid NSIDs, but handle gracefully

     

       98
       98
       +
                   return format!("{}.rs", sanitize_name(parts[0])).into();

     

       99
       99
       +
               }

     

       100
       100
       +
       

     

       101
       101
       +
               let last = parts.last().unwrap();

     

       102
       102
       +
       

     

       103
       103
       +
               if *last == "defs" && parts.len() >= 3 {

     

       104
       104
       +
                   // defs go in parent module: com.atproto.label.defs → com_atproto/label.rs

     

       105
       105
       +
                   let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1]));

     

       106
       106
       +
                   if parts.len() == 3 {

     

       107
       107
       +
                       // com.atproto.defs → com_atproto.rs

     

       108
       108
       +
                       format!("{}.rs", first_two).into()

     

       109
       109
       +
                   } else {

     

       110
       110
       +
                       // com.atproto.label.defs → com_atproto/label.rs

     

       111
       111
       +
                       let middle: Vec<&str> = parts[2..parts.len() - 1].iter().copied().collect();

     

       112
       112
       +
                       let mut path = std::path::PathBuf::from(first_two);

     

       113
       113
       +
                       for segment in &middle[..middle.len() - 1] {

     

       114
       114
       +
                           path.push(sanitize_name(segment));

     

       115
       115
       +
                       }

     

       116
       116
       +
                       path.push(format!("{}.rs", sanitize_name(middle.last().unwrap())));

     

       117
       117
       +
                       path

     

       118
       118
       +
                   }

     

       119
       119
       +
               } else {

     

       120
       120
       +
                   // Regular path: app.bsky.feed.post → app_bsky/feed/post.rs

     

       121
       121
       +
                   let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1]));

     

       122
       122
       +
                   let mut path = std::path::PathBuf::from(first_two);

     

       123
       123
       +
       

     

       124
       124
       +
                   for segment in &parts[2..parts.len() - 1] {

     

       125
       125
       +
                       path.push(sanitize_name(segment));

     

       126
       126
       +
                   }

     

       127
       127
       +
       

     

       128
       128
       +
                   path.push(format!("{}.rs", sanitize_name(&last.to_snake_case())));

     

       129
       129
       +
                   path

     

       130
       130
       +
               }

     

       131
       131
       +
           }

     

       132
       132
       +
       }

+329

crates/jacquard-lexicon/src/codegen/output.rs

···

       1
       1
       +
       use crate::error::{CodegenError, Result};

     

       2
       2
       +
       use proc_macro2::TokenStream;

     

       3
       3
       +
       use quote::quote;

     

       4
       4
       +
       use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};

     

       5
       5
       +
       

     

       6
       6
       +
       use super::utils::{make_ident, sanitize_name};

     

       7
       7
       +
       use super::CodeGenerator;

     

       8
       8
       +
       

     

       9
       9
       +
       impl<'c> CodeGenerator<'c> {

     

       10
       10
       +
           /// Generate all code for the corpus, organized by file

     

       11
       11
       +
           /// Returns a map of file paths to (tokens, optional NSID)

     

       12
       12
       +
           pub fn generate_all(

     

       13
       13
       +
               &self,

     

       14
       14
       +
           ) -> Result<BTreeMap<std::path::PathBuf, (TokenStream, Option<String>)>> {

     

       15
       15
       +
               let mut file_contents: BTreeMap<std::path::PathBuf, Vec<TokenStream>> = BTreeMap::new();

     

       16
       16
       +
               let mut file_nsids: BTreeMap<std::path::PathBuf, String> = BTreeMap::new();

     

       17
       17
       +
       

     

       18
       18
       +
               // Generate code for all lexicons

     

       19
       19
       +
               for (nsid, doc) in self.corpus.iter() {

     

       20
       20
       +
                   let file_path = self.nsid_to_file_path(nsid.as_ref());

     

       21
       21
       +
       

     

       22
       22
       +
                   // Track which NSID this file is for

     

       23
       23
       +
                   file_nsids.insert(file_path.clone(), nsid.to_string());

     

       24
       24
       +
       

     

       25
       25
       +
                   for (def_name, def) in &doc.defs {

     

       26
       26
       +
                       let tokens = self.generate_def(nsid.as_ref(), def_name.as_ref(), def)?;

     

       27
       27
       +
                       file_contents

     

       28
       28
       +
                           .entry(file_path.clone())

     

       29
       29
       +
                           .or_default()

     

       30
       30
       +
                           .push(tokens);

     

       31
       31
       +
                   }

     

       32
       32
       +
               }

     

       33
       33
       +
       

     

       34
       34
       +
               // Combine all tokens for each file

     

       35
       35
       +
               let mut result = BTreeMap::new();

     

       36
       36
       +
               for (path, tokens_vec) in file_contents {

     

       37
       37
       +
                   let nsid = file_nsids.get(&path).cloned();

     

       38
       38
       +
                   result.insert(path, (quote! { #(#tokens_vec)* }, nsid));

     

       39
       39
       +
               }

     

       40
       40
       +
       

     

       41
       41
       +
               Ok(result)

     

       42
       42
       +
           }

     

       43
       43
       +
       

     

       44
       44
       +
           /// Generate parent module files with pub mod declarations

     

       45
       45
       +
           pub fn generate_module_tree(

     

       46
       46
       +
               &self,

     

       47
       47
       +
               file_map: &BTreeMap<std::path::PathBuf, (TokenStream, Option<String>)>,

     

       48
       48
       +
               defs_only: &BTreeMap<std::path::PathBuf, (TokenStream, Option<String>)>,

     

       49
       49
       +
           ) -> BTreeMap<std::path::PathBuf, (TokenStream, Option<String>)> {

     

       50
       50
       +
               // Track what modules each directory needs to declare

     

       51
       51
       +
               // Key: directory path, Value: set of module names (file stems)

     

       52
       52
       +
               let mut dir_modules: BTreeMap<std::path::PathBuf, BTreeSet<String>> = BTreeMap::new();

     

       53
       53
       +
       

     

       54
       54
       +
               // Collect all parent directories that have files

     

       55
       55
       +
               let mut all_dirs: BTreeSet<std::path::PathBuf> = BTreeSet::new();

     

       56
       56
       +
               for path in file_map.keys() {

     

       57
       57
       +
                   if let Some(parent_dir) = path.parent() {

     

       58
       58
       +
                       all_dirs.insert(parent_dir.to_path_buf());

     

       59
       59
       +
                   }

     

       60
       60
       +
               }

     

       61
       61
       +
       

     

       62
       62
       +
               for path in file_map.keys() {

     

       63
       63
       +
                   if let Some(parent_dir) = path.parent() {

     

       64
       64
       +
                       if let Some(file_stem) = path.file_stem().and_then(|s| s.to_str()) {

     

       65
       65
       +
                           // Skip mod.rs and lib.rs - they're module files, not modules to declare

     

       66
       66
       +
                           if file_stem == "mod" || file_stem == "lib" {

     

       67
       67
       +
                               continue;

     

       68
       68
       +
                           }

     

       69
       69
       +
       

     

       70
       70
       +
                           // Always add the module declaration to parent

     

       71
       71
       +
                           dir_modules

     

       72
       72
       +
                               .entry(parent_dir.to_path_buf())

     

       73
       73
       +
                               .or_default()

     

       74
       74
       +
                               .insert(file_stem.to_string());

     

       75
       75
       +
                       }

     

       76
       76
       +
                   }

     

       77
       77
       +
               }

     

       78
       78
       +
       

     

       79
       79
       +
               // Generate module files

     

       80
       80
       +
               let mut result = BTreeMap::new();

     

       81
       81
       +
       

     

       82
       82
       +
               for (dir, module_names) in dir_modules {

     

       83
       83
       +
                   let mod_file_path = if dir.components().count() == 0 {

     

       84
       84
       +
                       // Root directory -> lib.rs for library crates

     

       85
       85
       +
                       std::path::PathBuf::from("lib.rs")

     

       86
       86
       +
                   } else {

     

       87
       87
       +
                       // Subdirectory: app_bsky/feed -> app_bsky/feed.rs (Rust 2018 style)

     

       88
       88
       +
                       let dir_name = dir.file_name().and_then(|s| s.to_str()).unwrap_or("mod");

     

       89
       89
       +
                       let sanitized_dir_name = sanitize_name(dir_name);

     

       90
       90
       +
                       let mut path = dir

     

       91
       91
       +
                           .parent()

     

       92
       92
       +
                           .unwrap_or_else(|| std::path::Path::new(""))

     

       93
       93
       +
                           .to_path_buf();

     

       94
       94
       +
                       path.push(format!("{}.rs", sanitized_dir_name));

     

       95
       95
       +
                       path

     

       96
       96
       +
                   };

     

       97
       97
       +
       

     

       98
       98
       +
                   let is_root = dir.components().count() == 0;

     

       99
       99
       +
                   let mods: Vec<_> = module_names

     

       100
       100
       +
                       .iter()

     

       101
       101
       +
                       .map(|name| {

     

       102
       102
       +
                           let ident = make_ident(name);

     

       103
       103
       +
                           if is_root {

     

       104
       104
       +
                               // Top-level modules get feature gates

     

       105
       105
       +
                               quote! {

     

       106
       106
       +
                                   #[cfg(feature = #name)]

     

       107
       107
       +
                                   pub mod #ident;

     

       108
       108
       +
                               }

     

       109
       109
       +
                           } else {

     

       110
       110
       +
                               quote! { pub mod #ident; }

     

       111
       111
       +
                           }

     

       112
       112
       +
                       })

     

       113
       113
       +
                       .collect();

     

       114
       114
       +
       

     

       115
       115
       +
                   // If this file already exists in defs_only (e.g., from defs), merge the content

     

       116
       116
       +
                   let module_tokens = quote! { #(#mods)* };

     

       117
       117
       +
                   if let Some((existing_tokens, nsid)) = defs_only.get(&mod_file_path) {

     

       118
       118
       +
                       // Put module declarations FIRST, then existing defs content

     

       119
       119
       +
                       result.insert(

     

       120
       120
       +
                           mod_file_path,

     

       121
       121
       +
                           (quote! { #module_tokens #existing_tokens }, nsid.clone()),

     

       122
       122
       +
                       );

     

       123
       123
       +
                   } else {

     

       124
       124
       +
                       result.insert(mod_file_path, (module_tokens, None));

     

       125
       125
       +
                   }

     

       126
       126
       +
               }

     

       127
       127
       +
       

     

       128
       128
       +
               result

     

       129
       129
       +
           }

     

       130
       130
       +
       

     

       131
       131
       +
           /// Write all generated code to disk

     

       132
       132
       +
           pub fn write_to_disk(&self, output_dir: &std::path::Path) -> Result<()> {

     

       133
       133
       +
               // Generate all code (defs only)

     

       134
       134
       +
               let defs_files = self.generate_all()?;

     

       135
       135
       +
               let mut all_files = defs_files.clone();

     

       136
       136
       +
       

     

       137
       137
       +
               // Generate module tree iteratively until no new files appear

     

       138
       138
       +
               loop {

     

       139
       139
       +
                   let module_map = self.generate_module_tree(&all_files, &defs_files);

     

       140
       140
       +
                   let old_count = all_files.len();

     

       141
       141
       +
       

     

       142
       142
       +
                   // Merge new module files

     

       143
       143
       +
                   for (path, tokens) in module_map {

     

       144
       144
       +
                       all_files.insert(path, tokens);

     

       145
       145
       +
                   }

     

       146
       146
       +
       

     

       147
       147
       +
                   if all_files.len() == old_count {

     

       148
       148
       +
                       // No new files added

     

       149
       149
       +
                       break;

     

       150
       150
       +
                   }

     

       151
       151
       +
               }

     

       152
       152
       +
       

     

       153
       153
       +
               // Write to disk

     

       154
       154
       +
               for (path, (tokens, nsid)) in all_files {

     

       155
       155
       +
                   let full_path = output_dir.join(&path);

     

       156
       156
       +
       

     

       157
       157
       +
                   // Create parent directories

     

       158
       158
       +
                   if let Some(parent) = full_path.parent() {

     

       159
       159
       +
                       std::fs::create_dir_all(parent).map_err(|e| CodegenError::Other {

     

       160
       160
       +
                           message: format!("Failed to create directory {:?}: {}", parent, e),

     

       161
       161
       +
                           source: None,

     

       162
       162
       +
                       })?;

     

       163
       163
       +
                   }

     

       164
       164
       +
       

     

       165
       165
       +
                   // Format code

     

       166
       166
       +
                   let file: syn::File = syn::parse2(tokens.clone()).map_err(|e| CodegenError::Other {

     

       167
       167
       +
                       message: format!(

     

       168
       168
       +
                           "Failed to parse tokens for {:?}: {}\nTokens: {}",

     

       169
       169
       +
                           path, e, tokens

     

       170
       170
       +
                       ),

     

       171
       171
       +
                       source: None,

     

       172
       172
       +
                   })?;

     

       173
       173
       +
                   let mut formatted = prettyplease::unparse(&file);

     

       174
       174
       +
       

     

       175
       175
       +
                   // Add blank lines between top-level items for better readability

     

       176
       176
       +
                   let lines: Vec<&str> = formatted.lines().collect();

     

       177
       177
       +
                   let mut result_lines = Vec::new();

     

       178
       178
       +
       

     

       179
       179
       +
                   for (i, line) in lines.iter().enumerate() {

     

       180
       180
       +
                       result_lines.push(*line);

     

       181
       181
       +
       

     

       182
       182
       +
                       // Add blank line after closing braces that are at column 0 (top-level items)

     

       183
       183
       +
                       if *line == "}" && i + 1 < lines.len() && !lines[i + 1].is_empty() {

     

       184
       184
       +
                           result_lines.push("");

     

       185
       185
       +
                       }

     

       186
       186
       +
       

     

       187
       187
       +
                       // Add blank line after last pub mod declaration before structs/enums

     

       188
       188
       +
                       if line.starts_with("pub mod ") && i + 1 < lines.len() {

     

       189
       189
       +
                           let next_line = lines[i + 1];

     

       190
       190
       +
                           if !next_line.starts_with("pub mod ") && !next_line.is_empty() {

     

       191
       191
       +
                               result_lines.push("");

     

       192
       192
       +
                           }

     

       193
       193
       +
                       }

     

       194
       194
       +
                   }

     

       195
       195
       +
       

     

       196
       196
       +
                   formatted = result_lines.join("\n");

     

       197
       197
       +
       

     

       198
       198
       +
                   // Add header comment

     

       199
       199
       +
                   let header = if let Some(nsid) = nsid {

     

       200
       200
       +
                       format!(

     

       201
       201
       +
                           "// @generated by jacquard-lexicon. DO NOT EDIT.\n//\n// Lexicon: {}\n//\n// This file was automatically generated from Lexicon schemas.\n// Any manual changes will be overwritten on the next regeneration.\n\n",

     

       202
       202
       +
                           nsid

     

       203
       203
       +
                       )

     

       204
       204
       +
                   } else {

     

       205
       205
       +
                       "// @generated by jacquard-lexicon. DO NOT EDIT.\n//\n// This file was automatically generated from Lexicon schemas.\n// Any manual changes will be overwritten on the next regeneration.\n\n".to_string()

     

       206
       206
       +
                   };

     

       207
       207
       +
                   formatted = format!("{}{}", header, formatted);

     

       208
       208
       +
       

     

       209
       209
       +
                   // Write file

     

       210
       210
       +
                   std::fs::write(&full_path, formatted).map_err(|e| CodegenError::Other {

     

       211
       211
       +
                       message: format!("Failed to write file {:?}: {}", full_path, e),

     

       212
       212
       +
                       source: None,

     

       213
       213
       +
                   })?;

     

       214
       214
       +
               }

     

       215
       215
       +
       

     

       216
       216
       +
               Ok(())

     

       217
       217
       +
           }

     

       218
       218
       +
       

     

       219
       219
       +
           /// Get namespace dependencies collected during code generation

     

       220
       220
       +
           pub fn get_namespace_dependencies(

     

       221
       221
       +
               &self,

     

       222
       222
       +
           ) -> HashMap<String, HashSet<String>> {

     

       223
       223
       +
               self.namespace_deps.borrow().clone()

     

       224
       224
       +
           }

     

       225
       225
       +
       

     

       226
       226
       +
           /// Generate Cargo.toml features section from namespace dependencies

     

       227
       227
       +
           pub fn generate_cargo_features(&self, lib_rs_path: Option<&std::path::Path>) -> String {

     

       228
       228
       +
               use std::fmt::Write;

     

       229
       229
       +
       

     

       230
       230
       +
               let deps = self.namespace_deps.borrow();

     

       231
       231
       +
               let mut all_namespaces: HashSet<String> =

     

       232
       232
       +
                   HashSet::new();

     

       233
       233
       +
       

     

       234
       234
       +
               // Collect all namespaces from the corpus (first two segments of each NSID)

     

       235
       235
       +
               for (nsid, _doc) in self.corpus.iter() {

     

       236
       236
       +
                   let parts: Vec<_> = nsid.as_str().splitn(3, '.').collect();

     

       237
       237
       +
                   let namespace = if parts.len() >= 2 {

     

       238
       238
       +
                       format!("{}.{}", parts[0], parts[1])

     

       239
       239
       +
                   } else {

     

       240
       240
       +
                       nsid.to_string()

     

       241
       241
       +
                   };

     

       242
       242
       +
                   all_namespaces.insert(namespace);

     

       243
       243
       +
               }

     

       244
       244
       +
       

     

       245
       245
       +
               // Also collect existing feature names from lib.rs

     

       246
       246
       +
               let mut existing_features = HashSet::new();

     

       247
       247
       +
               if let Some(lib_rs) = lib_rs_path {

     

       248
       248
       +
                   if let Ok(content) = std::fs::read_to_string(lib_rs) {

     

       249
       249
       +
                       for line in content.lines() {

     

       250
       250
       +
                           if let Some(feature) = line

     

       251
       251
       +
                               .trim()

     

       252
       252
       +
                               .strip_prefix("#[cfg(feature = \"")

     

       253
       253
       +
                               .and_then(|s| s.strip_suffix("\")]"))

     

       254
       254
       +
                           {

     

       255
       255
       +
                               existing_features.insert(feature.to_string());

     

       256
       256
       +
                           }

     

       257
       257
       +
                       }

     

       258
       258
       +
                   }

     

       259
       259
       +
               }

     

       260
       260
       +
       

     

       261
       261
       +
               let mut output = String::new();

     

       262
       262
       +
               writeln!(&mut output, "# Generated namespace features").unwrap();

     

       263
       263
       +
       

     

       264
       264
       +
               // Convert namespace to feature name (matching module path sanitization)

     

       265
       265
       +
               let to_feature_name = |ns: &str| {

     

       266
       266
       +
                   ns.split('.')

     

       267
       267
       +
                       .map(|segment| {

     

       268
       268
       +
                           // Apply same sanitization as module names

     

       269
       269
       +
                           let mut result = segment.replace('-', "_");

     

       270
       270
       +
                           // Prefix with underscore if starts with digit

     

       271
       271
       +
                           if result.chars().next().map_or(false, |c| c.is_ascii_digit()) {

     

       272
       272
       +
                               result.insert(0, '_');

     

       273
       273
       +
                           }

     

       274
       274
       +
                           result

     

       275
       275
       +
                       })

     

       276
       276
       +
                       .collect::<Vec<_>>()

     

       277
       277
       +
                       .join("_")

     

       278
       278
       +
               };

     

       279
       279
       +
       

     

       280
       280
       +
               // Collect all feature names (from corpus + existing lib.rs)

     

       281
       281
       +
               let mut all_feature_names = HashSet::new();

     

       282
       282
       +
               for ns in &all_namespaces {

     

       283
       283
       +
                   all_feature_names.insert(to_feature_name(ns));

     

       284
       284
       +
               }

     

       285
       285
       +
               all_feature_names.extend(existing_features);

     

       286
       286
       +
       

     

       287
       287
       +
               // Sort for consistent output

     

       288
       288
       +
               let mut feature_names: Vec<_> = all_feature_names.iter().collect();

     

       289
       289
       +
               feature_names.sort();

     

       290
       290
       +
       

     

       291
       291
       +
               // Map namespace to feature name for dependency lookup

     

       292
       292
       +
               let mut ns_to_feature: HashMap<&str, String> =

     

       293
       293
       +
                   HashMap::new();

     

       294
       294
       +
               for ns in &all_namespaces {

     

       295
       295
       +
                   ns_to_feature.insert(ns.as_str(), to_feature_name(ns));

     

       296
       296
       +
               }

     

       297
       297
       +
       

     

       298
       298
       +
               for feature_name in feature_names {

     

       299
       299
       +
                   // Find corresponding namespace for this feature (if any) to look up deps

     

       300
       300
       +
                   let feature_deps: Vec<String> = all_namespaces

     

       301
       301
       +
                       .iter()

     

       302
       302
       +
                       .find(|ns| to_feature_name(ns) == *feature_name)

     

       303
       303
       +
                       .and_then(|ns| deps.get(ns.as_str()))

     

       304
       304
       +
                       .map(|ns_deps| {

     

       305
       305
       +
                           let mut dep_features: Vec<_> = ns_deps

     

       306
       306
       +
                               .iter()

     

       307
       307
       +
                               .map(|d| format!("\"{}\"", to_feature_name(d)))

     

       308
       308
       +
                               .collect();

     

       309
       309
       +
                           dep_features.sort();

     

       310
       310
       +
                           dep_features

     

       311
       311
       +
                       })

     

       312
       312
       +
                       .unwrap_or_default();

     

       313
       313
       +
       

     

       314
       314
       +
                   if !feature_deps.is_empty() {

     

       315
       315
       +
                       writeln!(

     

       316
       316
       +
                           &mut output,

     

       317
       317
       +
                           "{} = [{}]",

     

       318
       318
       +
                           feature_name,

     

       319
       319
       +
                           feature_deps.join(", ")

     

       320
       320
       +
                       )

     

       321
       321
       +
                       .unwrap();

     

       322
       322
       +
                   } else {

     

       323
       323
       +
                       writeln!(&mut output, "{} = []", feature_name).unwrap();

     

       324
       324
       +
                   }

     

       325
       325
       +
               }

     

       326
       326
       +
       

     

       327
       327
       +
               output

     

       328
       328
       +
           }

     

       329
       329
       +
       }

+759

crates/jacquard-lexicon/src/codegen/structs.rs

···

       1
       1
       +
       use crate::error::Result;

     

       2
       2
       +
       use crate::lexicon::{

     

       3
       3
       +
           LexArrayItem, LexInteger, LexObject, LexObjectProperty, LexRecord, LexString,

     

       4
       4
       +
       };

     

       5
       5
       +
       use heck::{ToPascalCase, ToSnakeCase};

     

       6
       6
       +
       use proc_macro2::TokenStream;

     

       7
       7
       +
       use quote::quote;

     

       8
       8
       +
       

     

       9
       9
       +
       use super::utils::{make_ident, value_to_variant_name};

     

       10
       10
       +
       use super::CodeGenerator;

     

       11
       11
       +
       

     

       12
       12
       +
       /// Enum variant kind for IntoStatic generation

     

       13
       13
       +
       #[derive(Debug, Clone)]

     

       14
       14
       +
       #[allow(dead_code)]

     

       15
       15
       +
       pub(super) enum EnumVariantKind {

     

       16
       16
       +
           Unit,

     

       17
       17
       +
           Tuple,

     

       18
       18
       +
           Struct(Vec<String>),

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       impl<'c> CodeGenerator<'c> {

     

       22
       22
       +
           pub(super) fn generate_record(

     

       23
       23
       +
               &self,

     

       24
       24
       +
               nsid: &str,

     

       25
       25
       +
               def_name: &str,

     

       26
       26
       +
               record: &LexRecord<'static>,

     

       27
       27
       +
           ) -> Result<TokenStream> {

     

       28
       28
       +
               match &record.record {

     

       29
       29
       +
                   crate::lexicon::LexRecordRecord::Object(obj) => {

     

       30
       30
       +
                       let type_name = self.def_to_type_name(nsid, def_name);

     

       31
       31
       +
                       let ident = syn::Ident::new(&type_name, proc_macro2::Span::call_site());

     

       32
       32
       +
       

     

       33
       33
       +
                       // Generate main struct fields

     

       34
       34
       +
                       let fields = self.generate_object_fields(nsid, &type_name, obj, false)?;

     

       35
       35
       +
                       let doc = self.generate_doc_comment(record.description.as_ref());

     

       36
       36
       +
       

     

       37
       37
       +
                       // Records always get a lifetime since they have the #[lexicon] attribute

     

       38
       38
       +
                       // which adds extra_data: BTreeMap<..., Data<'a>>

     

       39
       39
       +
                       let struct_def = quote! {

     

       40
       40
       +
                           #doc

     

       41
       41
       +
                           #[jacquard_derive::lexicon]

     

       42
       42
       +
                           #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       43
       43
       +
                           #[serde(rename_all = "camelCase")]

     

       44
       44
       +
                           pub struct #ident<'a> {

     

       45
       45
       +
                               #fields

     

       46
       46
       +
                           }

     

       47
       47
       +
                       };

     

       48
       48
       +
       

     

       49
       49
       +
                       // Generate union types and nested object types for this record

     

       50
       50
       +
                       let mut unions = Vec::new();

     

       51
       51
       +
                       for (field_name, field_type) in &obj.properties {

     

       52
       52
       +
                           match field_type {

     

       53
       53
       +
                               LexObjectProperty::Union(union) => {

     

       54
       54
       +
                                   // Skip empty, single-variant unions unless they're self-referential

     

       55
       55
       +
                                   if !union.refs.is_empty() && (union.refs.len() > 1 || self.is_self_referential_union(nsid, &type_name, union)) {

     

       56
       56
       +
                                       let union_name = self.generate_field_type_name(nsid, &type_name, field_name, "");

     

       57
       57
       +
                                       let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       58
       58
       +
                                       let union_def =

     

       59
       59
       +
                                           self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       60
       60
       +
                                       unions.push(union_def);

     

       61
       61
       +
                                   }

     

       62
       62
       +
                               }

     

       63
       63
       +
                               LexObjectProperty::Object(nested_obj) => {

     

       64
       64
       +
                                   let object_name = self.generate_field_type_name(nsid, &type_name, field_name, "");

     

       65
       65
       +
                                   let obj_def = self.generate_object(nsid, &object_name, nested_obj)?;

     

       66
       66
       +
                                   unions.push(obj_def);

     

       67
       67
       +
                               }

     

       68
       68
       +
                               LexObjectProperty::Array(array) => {

     

       69
       69
       +
                                   if let LexArrayItem::Union(union) = &array.items {

     

       70
       70
       +
                                       // Skip single-variant array unions

     

       71
       71
       +
                                       if union.refs.len() > 1 {

     

       72
       72
       +
                                           let union_name = self.generate_field_type_name(nsid, &type_name, field_name, "Item");

     

       73
       73
       +
                                           let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       74
       74
       +
                                           let union_def = self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       75
       75
       +
                                           unions.push(union_def);

     

       76
       76
       +
                                       }

     

       77
       77
       +
                                   }

     

       78
       78
       +
                               }

     

       79
       79
       +
                               _ => {}

     

       80
       80
       +
                           }

     

       81
       81
       +
                       }

     

       82
       82
       +
       

     

       83
       83
       +
                       // Generate Collection trait impl

     

       84
       84
       +
                       let collection_impl = quote! {

     

       85
       85
       +
                           impl jacquard_common::types::collection::Collection for #ident<'_> {

     

       86
       86
       +
                               const NSID: &'static str = #nsid;

     

       87
       87
       +
                           }

     

       88
       88
       +
                       };

     

       89
       89
       +
       

     

       90
       90
       +
                       Ok(quote! {

     

       91
       91
       +
                           #struct_def

     

       92
       92
       +
                           #(#unions)*

     

       93
       93
       +
                           #collection_impl

     

       94
       94
       +
                       })

     

       95
       95
       +
                   }

     

       96
       96
       +
               }

     

       97
       97
       +
           }

     

       98
       98
       +
       

     

       99
       99
       +
           /// Generate an object type

     

       100
       100
       +
           pub(super) fn generate_object(

     

       101
       101
       +
               &self,

     

       102
       102
       +
               nsid: &str,

     

       103
       103
       +
               def_name: &str,

     

       104
       104
       +
               obj: &LexObject<'static>,

     

       105
       105
       +
           ) -> Result<TokenStream> {

     

       106
       106
       +
               let type_name = self.def_to_type_name(nsid, def_name);

     

       107
       107
       +
               let ident = syn::Ident::new(&type_name, proc_macro2::Span::call_site());

     

       108
       108
       +
       

     

       109
       109
       +
               let fields = self.generate_object_fields(nsid, &type_name, obj, false)?;

     

       110
       110
       +
               let doc = self.generate_doc_comment(obj.description.as_ref());

     

       111
       111
       +
       

     

       112
       112
       +
               // Objects always get a lifetime since they have the #[lexicon] attribute

     

       113
       113
       +
               // which adds extra_data: BTreeMap<..., Data<'a>>

     

       114
       114
       +
               let struct_def = quote! {

     

       115
       115
       +
                   #doc

     

       116
       116
       +
                   #[jacquard_derive::lexicon]

     

       117
       117
       +
                   #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       118
       118
       +
                   #[serde(rename_all = "camelCase")]

     

       119
       119
       +
                   pub struct #ident<'a> {

     

       120
       120
       +
                       #fields

     

       121
       121
       +
                   }

     

       122
       122
       +
               };

     

       123
       123
       +
       

     

       124
       124
       +
               // Generate union types and nested object types for this object

     

       125
       125
       +
               let mut unions = Vec::new();

     

       126
       126
       +
               for (field_name, field_type) in &obj.properties {

     

       127
       127
       +
                   match field_type {

     

       128
       128
       +
                       LexObjectProperty::Union(union) => {

     

       129
       129
       +
                           // Skip empty, single-variant unions unless they're self-referential

     

       130
       130
       +
                           if !union.refs.is_empty() && (union.refs.len() > 1 || self.is_self_referential_union(nsid, &type_name, union)) {

     

       131
       131
       +
                               let union_name = self.generate_field_type_name(nsid, &type_name, field_name, "");

     

       132
       132
       +
                               let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       133
       133
       +
                               let union_def =

     

       134
       134
       +
                                   self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       135
       135
       +
                               unions.push(union_def);

     

       136
       136
       +
                           }

     

       137
       137
       +
                       }

     

       138
       138
       +
                       LexObjectProperty::Object(nested_obj) => {

     

       139
       139
       +
                           let object_name = self.generate_field_type_name(nsid, &type_name, field_name, "");

     

       140
       140
       +
                           let obj_def = self.generate_object(nsid, &object_name, nested_obj)?;

     

       141
       141
       +
                           unions.push(obj_def);

     

       142
       142
       +
                       }

     

       143
       143
       +
                       LexObjectProperty::Array(array) => {

     

       144
       144
       +
                           if let LexArrayItem::Union(union) = &array.items {

     

       145
       145
       +
                               // Skip single-variant array unions

     

       146
       146
       +
                               if union.refs.len() > 1 {

     

       147
       147
       +
                                   let union_name = self.generate_field_type_name(nsid, &type_name, field_name, "Item");

     

       148
       148
       +
                                   let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       149
       149
       +
                                   let union_def = self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       150
       150
       +
                                   unions.push(union_def);

     

       151
       151
       +
                               }

     

       152
       152
       +
                           }

     

       153
       153
       +
                       }

     

       154
       154
       +
                       _ => {}

     

       155
       155
       +
                   }

     

       156
       156
       +
               }

     

       157
       157
       +
       

     

       158
       158
       +
               Ok(quote! {

     

       159
       159
       +
                   #struct_def

     

       160
       160
       +
                   #(#unions)*

     

       161
       161
       +
               })

     

       162
       162
       +
           }

     

       163
       163
       +
       

     

       164
       164
       +
           /// Generate fields for an object

     

       165
       165
       +
           pub(super) fn generate_object_fields(

     

       166
       166
       +
               &self,

     

       167
       167
       +
               nsid: &str,

     

       168
       168
       +
               parent_type_name: &str,

     

       169
       169
       +
               obj: &LexObject<'static>,

     

       170
       170
       +
               is_builder: bool,

     

       171
       171
       +
           ) -> Result<TokenStream> {

     

       172
       172
       +
               let required = obj.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]);

     

       173
       173
       +
       

     

       174
       174
       +
               let mut fields = Vec::new();

     

       175
       175
       +
               for (field_name, field_type) in &obj.properties {

     

       176
       176
       +
                   let is_required = required.contains(field_name);

     

       177
       177
       +
                   let field_tokens = self.generate_field(

     

       178
       178
       +
                       nsid,

     

       179
       179
       +
                       parent_type_name,

     

       180
       180
       +
                       field_name,

     

       181
       181
       +
                       field_type,

     

       182
       182
       +
                       is_required,

     

       183
       183
       +
                       is_builder,

     

       184
       184
       +
                   )?;

     

       185
       185
       +
                   fields.push(field_tokens);

     

       186
       186
       +
               }

     

       187
       187
       +
       

     

       188
       188
       +
               Ok(quote! { #(#fields)* })

     

       189
       189
       +
           }

     

       190
       190
       +
       

     

       191
       191
       +
           /// Generate a single field

     

       192
       192
       +
           pub(super) fn generate_field(

     

       193
       193
       +
               &self,

     

       194
       194
       +
               nsid: &str,

     

       195
       195
       +
               parent_type_name: &str,

     

       196
       196
       +
               field_name: &str,

     

       197
       197
       +
               field_type: &LexObjectProperty<'static>,

     

       198
       198
       +
               is_required: bool,

     

       199
       199
       +
               is_builder: bool,

     

       200
       200
       +
           ) -> Result<TokenStream> {

     

       201
       201
       +
               if field_name.is_empty() {

     

       202
       202
       +
                   eprintln!(

     

       203
       203
       +
                       "Warning: Empty field name in lexicon '{}' type '{}', using 'unknown' as fallback",

     

       204
       204
       +
                       nsid, parent_type_name

     

       205
       205
       +
                   );

     

       206
       206
       +
               }

     

       207
       207
       +
               let field_ident = make_ident(&field_name.to_snake_case());

     

       208
       208
       +
       

     

       209
       209
       +
               let rust_type =

     

       210
       210
       +
                   self.property_to_rust_type(nsid, parent_type_name, field_name, field_type)?;

     

       211
       211
       +
               let needs_lifetime = self.property_needs_lifetime(field_type);

     

       212
       212
       +
       

     

       213
       213
       +
               // Check if this is a CowStr field for builder(into) attribute

     

       214
       214
       +
               let is_cowstr = matches!(field_type, LexObjectProperty::String(s) if s.format.is_none());

     

       215
       215
       +
       

     

       216
       216
       +
               let rust_type = if is_required {

     

       217
       217
       +
                   rust_type

     

       218
       218
       +
               } else {

     

       219
       219
       +
                   quote! { std::option::Option<#rust_type> }

     

       220
       220
       +
               };

     

       221
       221
       +
       

     

       222
       222
       +
               // Extract description from field type

     

       223
       223
       +
               let description = match field_type {

     

       224
       224
       +
                   LexObjectProperty::Ref(r) => r.description.as_ref(),

     

       225
       225
       +
                   LexObjectProperty::Union(u) => u.description.as_ref(),

     

       226
       226
       +
                   LexObjectProperty::Bytes(b) => b.description.as_ref(),

     

       227
       227
       +
                   LexObjectProperty::CidLink(c) => c.description.as_ref(),

     

       228
       228
       +
                   LexObjectProperty::Array(a) => a.description.as_ref(),

     

       229
       229
       +
                   LexObjectProperty::Blob(b) => b.description.as_ref(),

     

       230
       230
       +
                   LexObjectProperty::Object(o) => o.description.as_ref(),

     

       231
       231
       +
                   LexObjectProperty::Boolean(b) => b.description.as_ref(),

     

       232
       232
       +
                   LexObjectProperty::Integer(i) => i.description.as_ref(),

     

       233
       233
       +
                   LexObjectProperty::String(s) => s.description.as_ref(),

     

       234
       234
       +
                   LexObjectProperty::Unknown(u) => u.description.as_ref(),

     

       235
       235
       +
               };

     

       236
       236
       +
               let doc = self.generate_doc_comment(description);

     

       237
       237
       +
       

     

       238
       238
       +
               let mut attrs = Vec::new();

     

       239
       239
       +
       

     

       240
       240
       +
               if !is_required {

     

       241
       241
       +
                   attrs.push(quote! { #[serde(skip_serializing_if = "std::option::Option::is_none")] });

     

       242
       242
       +
               }

     

       243
       243
       +
       

     

       244
       244
       +
               // Add serde(borrow) to all fields with lifetimes

     

       245
       245
       +
               if needs_lifetime {

     

       246
       246
       +
                   attrs.push(quote! { #[serde(borrow)] });

     

       247
       247
       +
               }

     

       248
       248
       +
       

     

       249
       249
       +
               // Add builder(into) for CowStr fields to allow String, &str, etc., but only for builder structs

     

       250
       250
       +
               if is_builder && is_cowstr {

     

       251
       251
       +
                   attrs.push(quote! { #[builder(into)] });

     

       252
       252
       +
               }

     

       253
       253
       +
       

     

       254
       254
       +
               Ok(quote! {

     

       255
       255
       +
                   #doc

     

       256
       256
       +
                   #(#attrs)*

     

       257
       257
       +
                   pub #field_ident: #rust_type,

     

       258
       258
       +
               })

     

       259
       259
       +
           }

     

       260
       260
       +
       

     

       261
       261
       +
           /// Generate a union enum for refs

     

       262
       262
       +
           pub fn generate_union(

     

       263
       263
       +
               &self,

     

       264
       264
       +
               current_nsid: &str,

     

       265
       265
       +
               union_name: &str,

     

       266
       266
       +
               refs: &[jacquard_common::CowStr<'static>],

     

       267
       267
       +
               description: Option<&str>,

     

       268
       268
       +
               closed: Option<bool>,

     

       269
       269
       +
           ) -> Result<TokenStream> {

     

       270
       270
       +
               let enum_ident = syn::Ident::new(union_name, proc_macro2::Span::call_site());

     

       271
       271
       +
       

     

       272
       272
       +
               // Extract namespace prefix from current NSID (first two segments: "sh.weaver" from "sh.weaver.embed.recordWithMedia")

     

       273
       273
       +
               let parts: Vec<_> = current_nsid.splitn(3, '.').collect();

     

       274
       274
       +
               let current_namespace = if parts.len() >= 2 {

     

       275
       275
       +
                   format!("{}.{}", parts[0], parts[1])

     

       276
       276
       +
               } else {

     

       277
       277
       +
                   current_nsid.to_string()

     

       278
       278
       +
               };

     

       279
       279
       +
       

     

       280
       280
       +
               // First pass: collect all variant names and detect collisions

     

       281
       281
       +
               #[derive(Debug)]

     

       282
       282
       +
               struct VariantInfo {

     

       283
       283
       +
                   ref_str: String,

     

       284
       284
       +
                   ref_nsid: String,

     

       285
       285
       +
                   simple_name: String,

     

       286
       286
       +
                   is_current_namespace: bool,

     

       287
       287
       +
               }

     

       288
       288
       +
       

     

       289
       289
       +
               let mut variant_infos = Vec::new();

     

       290
       290
       +
               for ref_str in refs {

     

       291
       291
       +
                   // Normalize local refs (starting with #) by prepending current NSID

     

       292
       292
       +
                   let normalized_ref = if ref_str.starts_with('#') {

     

       293
       293
       +
                       format!("{}{}", current_nsid, ref_str)

     

       294
       294
       +
                   } else {

     

       295
       295
       +
                       ref_str.to_string()

     

       296
       296
       +
                   };

     

       297
       297
       +
       

     

       298
       298
       +
                   // Parse ref to get NSID and def name

     

       299
       299
       +
                   let (ref_nsid_str, ref_def) = if let Some((nsid, fragment)) = normalized_ref.split_once('#') {

     

       300
       300
       +
                       (nsid, fragment)

     

       301
       301
       +
                   } else {

     

       302
       302
       +
                       (normalized_ref.as_str(), "main")

     

       303
       303
       +
                   };

     

       304
       304
       +
       

     

       305
       305
       +
                   // Skip unknown refs - they'll be handled by Unknown variant

     

       306
       306
       +
                   if !self.corpus.ref_exists(&normalized_ref) {

     

       307
       307
       +
                       continue;

     

       308
       308
       +
                   }

     

       309
       309
       +
       

     

       310
       310
       +
                   // Check if ref is in current namespace and if it's the same module

     

       311
       311
       +
                   let is_current_namespace = ref_nsid_str.starts_with(&current_namespace);

     

       312
       312
       +
                   let is_same_module = ref_nsid_str == current_nsid;

     

       313
       313
       +
       

     

       314
       314
       +
                   // Generate simple variant name (without namespace prefix)

     

       315
       315
       +
                   let last_segment = ref_nsid_str.split('.').last().unwrap();

     

       316
       316
       +
                   let simple_name = if ref_def == "main" {

     

       317
       317
       +
                       // For main, use the last NSID segment

     

       318
       318
       +
                       // e.g. app.bsky.embed.images#main -> Images

     

       319
       319
       +
                       last_segment.to_pascal_case()

     

       320
       320
       +
                   } else if last_segment == "defs" {

     

       321
       321
       +
                       // For defs modules, just use the fragment name without "Defs" prefix

     

       322
       322
       +
                       // e.g. app.bsky.embed.defs#images -> Images (not DefsImages)

     

       323
       323
       +
                       ref_def.to_pascal_case()

     

       324
       324
       +
                   } else if is_same_module {

     

       325
       325
       +
                       // For same-module refs, just use the fragment name to avoid redundancy

     

       326
       326
       +
                       // e.g. sh.weaver.embed.records#viewRecord in records.rs -> ViewRecord (not RecordsViewRecord)

     

       327
       327
       +
                       ref_def.to_pascal_case()

     

       328
       328
       +
                   } else {

     

       329
       329
       +
                       // For other fragments, include the last NSID segment to avoid collisions

     

       330
       330
       +
                       // e.g. app.bsky.embed.images#view -> ImagesView

     

       331
       331
       +
                       //      app.bsky.embed.video#view -> VideoView

     

       332
       332
       +
                       format!("{}{}", last_segment.to_pascal_case(), ref_def.to_pascal_case())

     

       333
       333
       +
                   };

     

       334
       334
       +
       

     

       335
       335
       +
                   variant_infos.push(VariantInfo {

     

       336
       336
       +
                       ref_str: normalized_ref.clone(),

     

       337
       337
       +
                       ref_nsid: ref_nsid_str.to_string(),

     

       338
       338
       +
                       simple_name,

     

       339
       339
       +
                       is_current_namespace,

     

       340
       340
       +
                   });

     

       341
       341
       +
               }

     

       342
       342
       +
       

     

       343
       343
       +
               // Second pass: detect collisions and disambiguate

     

       344
       344
       +
               use std::collections::HashMap;

     

       345
       345
       +
               let mut name_counts: HashMap<String, usize> = HashMap::new();

     

       346
       346
       +
               for info in &variant_infos {

     

       347
       347
       +
                   *name_counts.entry(info.simple_name.clone()).or_insert(0) += 1;

     

       348
       348
       +
               }

     

       349
       349
       +
       

     

       350
       350
       +
               let mut variants = Vec::new();

     

       351
       351
       +
               for info in variant_infos {

     

       352
       352
       +
                   let has_collision = name_counts.get(&info.simple_name).copied().unwrap_or(0) > 1;

     

       353
       353
       +
       

     

       354
       354
       +
                   // Track namespace dependency for foreign refs

     

       355
       355
       +
                   if !info.is_current_namespace {

     

       356
       356
       +
                       let parts: Vec<_> = info.ref_nsid.splitn(3, '.').collect();

     

       357
       357
       +
                       let foreign_namespace = if parts.len() >= 2 {

     

       358
       358
       +
                           format!("{}.{}", parts[0], parts[1])

     

       359
       359
       +
                       } else {

     

       360
       360
       +
                           info.ref_nsid.to_string()

     

       361
       361
       +
                       };

     

       362
       362
       +
                       self.namespace_deps

     

       363
       363
       +
                           .borrow_mut()

     

       364
       364
       +
                           .entry(current_namespace.clone())

     

       365
       365
       +
                           .or_default()

     

       366
       366
       +
                           .insert(foreign_namespace);

     

       367
       367
       +
                   }

     

       368
       368
       +
       

     

       369
       369
       +
                   // Disambiguate: add second NSID segment prefix only to foreign refs when there's a collision

     

       370
       370
       +
                   let variant_name = if has_collision && !info.is_current_namespace {

     

       371
       371
       +
                       // Get second segment (namespace identifier: "bsky" from "app.bsky.embed.images")

     

       372
       372
       +
                       let segments: Vec<&str> = info.ref_nsid.split('.').collect();

     

       373
       373
       +
                       let prefix = if segments.len() >= 2 {

     

       374
       374
       +
                           segments[1].to_pascal_case()

     

       375
       375
       +
                       } else {

     

       376
       376
       +
                           // Fallback: use first segment if only one exists

     

       377
       377
       +
                           segments[0].to_pascal_case()

     

       378
       378
       +
                       };

     

       379
       379
       +
                       format!("{}{}", prefix, info.simple_name)

     

       380
       380
       +
                   } else {

     

       381
       381
       +
                       info.simple_name.clone()

     

       382
       382
       +
                   };

     

       383
       383
       +
       

     

       384
       384
       +
                   let variant_ident = syn::Ident::new(&variant_name, proc_macro2::Span::call_site());

     

       385
       385
       +
       

     

       386
       386
       +
                   // Get the Rust type for this ref

     

       387
       387
       +
                   let rust_type = self.ref_to_rust_type(&info.ref_str)?;

     

       388
       388
       +
       

     

       389
       389
       +
                   // Add serde rename for the full NSID

     

       390
       390
       +
                   let ref_str_literal = &info.ref_str;

     

       391
       391
       +
                   variants.push(quote! {

     

       392
       392
       +
                       #[serde(rename = #ref_str_literal)]

     

       393
       393
       +
                       #variant_ident(Box<#rust_type>)

     

       394
       394
       +
                   });

     

       395
       395
       +
               }

     

       396
       396
       +
       

     

       397
       397
       +
               let doc = description

     

       398
       398
       +
                   .map(|d| quote! { #[doc = #d] })

     

       399
       399
       +
                   .unwrap_or_else(|| quote! {});

     

       400
       400
       +
       

     

       401
       401
       +
               // Only add open_union if not closed

     

       402
       402
       +
               let is_open = closed != Some(true);

     

       403
       403
       +
       

     

       404
       404
       +
               if is_open {

     

       405
       405
       +
                   Ok(quote! {

     

       406
       406
       +
                       #doc

     

       407
       407
       +
                       #[jacquard_derive::open_union]

     

       408
       408
       +
                       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       409
       409
       +
                       #[serde(tag = "$type")]

     

       410
       410
       +
                       #[serde(bound(deserialize = "'de: 'a"))]

     

       411
       411
       +
                       pub enum #enum_ident<'a> {

     

       412
       412
       +
                           #(#variants,)*

     

       413
       413
       +
                       }

     

       414
       414
       +
                   })

     

       415
       415
       +
               } else {

     

       416
       416
       +
                   Ok(quote! {

     

       417
       417
       +
                       #doc

     

       418
       418
       +
                       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       419
       419
       +
                       #[serde(tag = "$type")]

     

       420
       420
       +
                       #[serde(bound(deserialize = "'de: 'a"))]

     

       421
       421
       +
                       pub enum #enum_ident<'a> {

     

       422
       422
       +
                           #(#variants,)*

     

       423
       423
       +
                       }

     

       424
       424
       +
                   })

     

       425
       425
       +
               }

     

       426
       426
       +
           }

     

       427
       427
       +
       

     

       428
       428
       +
           /// Generate enum for string with known values

     

       429
       429
       +
           pub(super) fn generate_known_values_enum(

     

       430
       430
       +
               &self,

     

       431
       431
       +
               nsid: &str,

     

       432
       432
       +
               def_name: &str,

     

       433
       433
       +
               string: &LexString<'static>,

     

       434
       434
       +
           ) -> Result<TokenStream> {

     

       435
       435
       +
               let type_name = self.def_to_type_name(nsid, def_name);

     

       436
       436
       +
               let ident = syn::Ident::new(&type_name, proc_macro2::Span::call_site());

     

       437
       437
       +
       

     

       438
       438
       +
               let known_values = string.known_values.as_ref().unwrap();

     

       439
       439
       +
               let mut variants = Vec::new();

     

       440
       440
       +
               let mut from_str_arms = Vec::new();

     

       441
       441
       +
               let mut as_str_arms = Vec::new();

     

       442
       442
       +
       

     

       443
       443
       +
               for value in known_values {

     

       444
       444
       +
                   // Convert value to valid Rust identifier

     

       445
       445
       +
                   let value_str = value.as_ref();

     

       446
       446
       +
                   let variant_name = value_to_variant_name(value_str);

     

       447
       447
       +
                   let variant_ident = syn::Ident::new(&variant_name, proc_macro2::Span::call_site());

     

       448
       448
       +
       

     

       449
       449
       +
                   variants.push(quote! {

     

       450
       450
       +
                       #variant_ident

     

       451
       451
       +
                   });

     

       452
       452
       +
       

     

       453
       453
       +
                   from_str_arms.push(quote! {

     

       454
       454
       +
                       #value_str => Self::#variant_ident

     

       455
       455
       +
                   });

     

       456
       456
       +
       

     

       457
       457
       +
                   as_str_arms.push(quote! {

     

       458
       458
       +
                       Self::#variant_ident => #value_str

     

       459
       459
       +
                   });

     

       460
       460
       +
               }

     

       461
       461
       +
       

     

       462
       462
       +
               let doc = self.generate_doc_comment(string.description.as_ref());

     

       463
       463
       +
       

     

       464
       464
       +
               // Generate IntoStatic impl

     

       465
       465
       +
               let variant_info: Vec<(String, EnumVariantKind)> = known_values

     

       466
       466
       +
                   .iter()

     

       467
       467
       +
                   .map(|value| {

     

       468
       468
       +
                       let variant_name = value_to_variant_name(value.as_ref());

     

       469
       469
       +
                       (variant_name, EnumVariantKind::Unit)

     

       470
       470
       +
                   })

     

       471
       471
       +
                   .chain(std::iter::once((

     

       472
       472
       +
                       "Other".to_string(),

     

       473
       473
       +
                       EnumVariantKind::Tuple,

     

       474
       474
       +
                   )))

     

       475
       475
       +
                   .collect();

     

       476
       476
       +
               let into_static_impl =

     

       477
       477
       +
                   self.generate_into_static_for_enum(&type_name, &variant_info, true, false);

     

       478
       478
       +
       

     

       479
       479
       +
               Ok(quote! {

     

       480
       480
       +
                   #doc

     

       481
       481
       +
                   #[derive(Debug, Clone, PartialEq, Eq, Hash)]

     

       482
       482
       +
                   pub enum #ident<'a> {

     

       483
       483
       +
                       #(#variants,)*

     

       484
       484
       +
                       Other(jacquard_common::CowStr<'a>),

     

       485
       485
       +
                   }

     

       486
       486
       +
       

     

       487
       487
       +
                   impl<'a> #ident<'a> {

     

       488
       488
       +
                       pub fn as_str(&self) -> &str {

     

       489
       489
       +
                           match self {

     

       490
       490
       +
                               #(#as_str_arms,)*

     

       491
       491
       +
                               Self::Other(s) => s.as_ref(),

     

       492
       492
       +
                           }

     

       493
       493
       +
                       }

     

       494
       494
       +
                   }

     

       495
       495
       +
       

     

       496
       496
       +
                   impl<'a> From<&'a str> for #ident<'a> {

     

       497
       497
       +
                       fn from(s: &'a str) -> Self {

     

       498
       498
       +
                           match s {

     

       499
       499
       +
                               #(#from_str_arms,)*

     

       500
       500
       +
                               _ => Self::Other(jacquard_common::CowStr::from(s)),

     

       501
       501
       +
                           }

     

       502
       502
       +
                       }

     

       503
       503
       +
                   }

     

       504
       504
       +
       

     

       505
       505
       +
                   impl<'a> From<String> for #ident<'a> {

     

       506
       506
       +
                       fn from(s: String) -> Self {

     

       507
       507
       +
                           match s.as_str() {

     

       508
       508
       +
                               #(#from_str_arms,)*

     

       509
       509
       +
                               _ => Self::Other(jacquard_common::CowStr::from(s)),

     

       510
       510
       +
                           }

     

       511
       511
       +
                       }

     

       512
       512
       +
                   }

     

       513
       513
       +
       

     

       514
       514
       +
                   impl<'a> AsRef<str> for #ident<'a> {

     

       515
       515
       +
                       fn as_ref(&self) -> &str {

     

       516
       516
       +
                           self.as_str()

     

       517
       517
       +
                       }

     

       518
       518
       +
                   }

     

       519
       519
       +
       

     

       520
       520
       +
                   impl<'a> serde::Serialize for #ident<'a> {

     

       521
       521
       +
                       fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

     

       522
       522
       +
                       where

     

       523
       523
       +
                           S: serde::Serializer,

     

       524
       524
       +
                       {

     

       525
       525
       +
                           serializer.serialize_str(self.as_str())

     

       526
       526
       +
                       }

     

       527
       527
       +
                   }

     

       528
       528
       +
       

     

       529
       529
       +
                   impl<'de, 'a> serde::Deserialize<'de> for #ident<'a>

     

       530
       530
       +
                   where

     

       531
       531
       +
                       'de: 'a,

     

       532
       532
       +
                   {

     

       533
       533
       +
                       fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

     

       534
       534
       +
                       where

     

       535
       535
       +
                           D: serde::Deserializer<'de>,

     

       536
       536
       +
                       {

     

       537
       537
       +
                           let s = <&'de str>::deserialize(deserializer)?;

     

       538
       538
       +
                           Ok(Self::from(s))

     

       539
       539
       +
                       }

     

       540
       540
       +
                   }

     

       541
       541
       +
       

     

       542
       542
       +
                   #into_static_impl

     

       543
       543
       +
               })

     

       544
       544
       +
           }

     

       545
       545
       +
       

     

       546
       546
       +
           /// Generate enum for integer with enum values

     

       547
       547
       +
           pub(super) fn generate_integer_enum(

     

       548
       548
       +
               &self,

     

       549
       549
       +
               nsid: &str,

     

       550
       550
       +
               def_name: &str,

     

       551
       551
       +
               integer: &LexInteger<'static>,

     

       552
       552
       +
           ) -> Result<TokenStream> {

     

       553
       553
       +
               let type_name = self.def_to_type_name(nsid, def_name);

     

       554
       554
       +
               let ident = syn::Ident::new(&type_name, proc_macro2::Span::call_site());

     

       555
       555
       +
       

     

       556
       556
       +
               let enum_values = integer.r#enum.as_ref().unwrap();

     

       557
       557
       +
               let mut variants = Vec::new();

     

       558
       558
       +
               let mut from_i64_arms = Vec::new();

     

       559
       559
       +
               let mut to_i64_arms = Vec::new();

     

       560
       560
       +
       

     

       561
       561
       +
               for value in enum_values {

     

       562
       562
       +
                   let variant_name = format!("Value{}", value.abs());

     

       563
       563
       +
                   let variant_ident = syn::Ident::new(&variant_name, proc_macro2::Span::call_site());

     

       564
       564
       +
       

     

       565
       565
       +
                   variants.push(quote! {

     

       566
       566
       +
                       #[serde(rename = #value)]

     

       567
       567
       +
                       #variant_ident

     

       568
       568
       +
                   });

     

       569
       569
       +
       

     

       570
       570
       +
                   from_i64_arms.push(quote! {

     

       571
       571
       +
                       #value => Self::#variant_ident

     

       572
       572
       +
                   });

     

       573
       573
       +
       

     

       574
       574
       +
                   to_i64_arms.push(quote! {

     

       575
       575
       +
                       Self::#variant_ident => #value

     

       576
       576
       +
                   });

     

       577
       577
       +
               }

     

       578
       578
       +
       

     

       579
       579
       +
               let doc = self.generate_doc_comment(integer.description.as_ref());

     

       580
       580
       +
       

     

       581
       581
       +
               Ok(quote! {

     

       582
       582
       +
                   #doc

     

       583
       583
       +
                   #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

     

       584
       584
       +
                   pub enum #ident {

     

       585
       585
       +
                       #(#variants,)*

     

       586
       586
       +
                       #[serde(untagged)]

     

       587
       587
       +
                       Other(i64),

     

       588
       588
       +
                   }

     

       589
       589
       +
       

     

       590
       590
       +
                   impl #ident {

     

       591
       591
       +
                       pub fn as_i64(&self) -> i64 {

     

       592
       592
       +
                           match self {

     

       593
       593
       +
                               #(#to_i64_arms,)*

     

       594
       594
       +
                               Self::Other(n) => *n,

     

       595
       595
       +
                           }

     

       596
       596
       +
                       }

     

       597
       597
       +
                   }

     

       598
       598
       +
       

     

       599
       599
       +
                   impl From<i64> for #ident {

     

       600
       600
       +
                       fn from(n: i64) -> Self {

     

       601
       601
       +
                           match n {

     

       602
       602
       +
                               #(#from_i64_arms,)*

     

       603
       603
       +
                               _ => Self::Other(n),

     

       604
       604
       +
                           }

     

       605
       605
       +
                       }

     

       606
       606
       +
                   }

     

       607
       607
       +
       

     

       608
       608
       +
                   impl serde::Serialize for #ident {

     

       609
       609
       +
                       fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

     

       610
       610
       +
                       where

     

       611
       611
       +
                           S: serde::Serializer,

     

       612
       612
       +
                       {

     

       613
       613
       +
                           serializer.serialize_i64(self.as_i64())

     

       614
       614
       +
                       }

     

       615
       615
       +
                   }

     

       616
       616
       +
       

     

       617
       617
       +
                   impl<'de> serde::Deserialize<'de> for #ident {

     

       618
       618
       +
                       fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

     

       619
       619
       +
                       where

     

       620
       620
       +
                           D: serde::Deserializer<'de>,

     

       621
       621
       +
                       {

     

       622
       622
       +
                           let n = i64::deserialize(deserializer)?;

     

       623
       623
       +
                           Ok(Self::from(n))

     

       624
       624
       +
                       }

     

       625
       625
       +
                   }

     

       626
       626
       +
               })

     

       627
       627
       +
           }

     

       628
       628
       +
       

     

       629
       629
       +
           /// Generate IntoStatic impl for a struct

     

       630
       630
       +
           #[allow(dead_code)]

     

       631
       631
       +
           pub(super) fn generate_into_static_for_struct(

     

       632
       632
       +
               &self,

     

       633
       633
       +
               type_name: &str,

     

       634
       634
       +
               field_names: &[&str],

     

       635
       635
       +
               has_lifetime: bool,

     

       636
       636
       +
               has_extra_data: bool,

     

       637
       637
       +
           ) -> TokenStream {

     

       638
       638
       +
               let ident = syn::Ident::new(type_name, proc_macro2::Span::call_site());

     

       639
       639
       +
       

     

       640
       640
       +
               let field_idents: Vec<_> = field_names

     

       641
       641
       +
                   .iter()

     

       642
       642
       +
                   .map(|name| make_ident(&name.to_snake_case()))

     

       643
       643
       +
                   .collect();

     

       644
       644
       +
       

     

       645
       645
       +
               if has_lifetime {

     

       646
       646
       +
                   let field_conversions: Vec<_> = field_idents

     

       647
       647
       +
                       .iter()

     

       648
       648
       +
                       .map(|field| quote! { #field: self.#field.into_static() })

     

       649
       649
       +
                       .collect();

     

       650
       650
       +
       

     

       651
       651
       +
                   let extra_data_conversion = if has_extra_data {

     

       652
       652
       +
                       quote! { extra_data: self.extra_data.into_static(), }

     

       653
       653
       +
                   } else {

     

       654
       654
       +
                       quote! {}

     

       655
       655
       +
                   };

     

       656
       656
       +
       

     

       657
       657
       +
                   quote! {

     

       658
       658
       +
                       impl jacquard_common::IntoStatic for #ident<'_> {

     

       659
       659
       +
                           type Output = #ident<'static>;

     

       660
       660
       +
       

     

       661
       661
       +
                           fn into_static(self) -> Self::Output {

     

       662
       662
       +
                               #ident {

     

       663
       663
       +
                                   #(#field_conversions,)*

     

       664
       664
       +
                                   #extra_data_conversion

     

       665
       665
       +
                               }

     

       666
       666
       +
                           }

     

       667
       667
       +
                       }

     

       668
       668
       +
                   }

     

       669
       669
       +
               } else {

     

       670
       670
       +
                   quote! {

     

       671
       671
       +
                       impl jacquard_common::IntoStatic for #ident {

     

       672
       672
       +
                           type Output = #ident;

     

       673
       673
       +
       

     

       674
       674
       +
                           fn into_static(self) -> Self::Output {

     

       675
       675
       +
                               self

     

       676
       676
       +
                           }

     

       677
       677
       +
                       }

     

       678
       678
       +
                   }

     

       679
       679
       +
               }

     

       680
       680
       +
           }

     

       681
       681
       +
       

     

       682
       682
       +
           /// Generate IntoStatic impl for an enum

     

       683
       683
       +
           pub(super) fn generate_into_static_for_enum(

     

       684
       684
       +
               &self,

     

       685
       685
       +
               type_name: &str,

     

       686
       686
       +
               variant_info: &[(String, EnumVariantKind)],

     

       687
       687
       +
               has_lifetime: bool,

     

       688
       688
       +
               is_open: bool,

     

       689
       689
       +
           ) -> TokenStream {

     

       690
       690
       +
               let ident = syn::Ident::new(type_name, proc_macro2::Span::call_site());

     

       691
       691
       +
       

     

       692
       692
       +
               if has_lifetime {

     

       693
       693
       +
                   let variant_conversions: Vec<_> = variant_info

     

       694
       694
       +
                       .iter()

     

       695
       695
       +
                       .map(|(variant_name, kind)| {

     

       696
       696
       +
                           let variant_ident = syn::Ident::new(variant_name, proc_macro2::Span::call_site());

     

       697
       697
       +
                           match kind {

     

       698
       698
       +
                               EnumVariantKind::Unit => {

     

       699
       699
       +
                                   quote! {

     

       700
       700
       +
                                       #ident::#variant_ident => #ident::#variant_ident

     

       701
       701
       +
                                   }

     

       702
       702
       +
                               }

     

       703
       703
       +
                               EnumVariantKind::Tuple => {

     

       704
       704
       +
                                   quote! {

     

       705
       705
       +
                                       #ident::#variant_ident(v) => #ident::#variant_ident(v.into_static())

     

       706
       706
       +
                                   }

     

       707
       707
       +
                               }

     

       708
       708
       +
                               EnumVariantKind::Struct(fields) => {

     

       709
       709
       +
                                   let field_idents: Vec<_> = fields

     

       710
       710
       +
                                       .iter()

     

       711
       711
       +
                                       .map(|f| make_ident(&f.to_snake_case()))

     

       712
       712
       +
                                       .collect();

     

       713
       713
       +
                                   let field_conversions: Vec<_> = field_idents

     

       714
       714
       +
                                       .iter()

     

       715
       715
       +
                                       .map(|f| quote! { #f: #f.into_static() })

     

       716
       716
       +
                                       .collect();

     

       717
       717
       +
                                   quote! {

     

       718
       718
       +
                                       #ident::#variant_ident { #(#field_idents,)* } => #ident::#variant_ident {

     

       719
       719
       +
                                           #(#field_conversions,)*

     

       720
       720
       +
                                       }

     

       721
       721
       +
                                   }

     

       722
       722
       +
                               }

     

       723
       723
       +
                           }

     

       724
       724
       +
                       })

     

       725
       725
       +
                       .collect();

     

       726
       726
       +
       

     

       727
       727
       +
                   let unknown_conversion = if is_open {

     

       728
       728
       +
                       quote! {

     

       729
       729
       +
                           #ident::Unknown(v) => #ident::Unknown(v.into_static()),

     

       730
       730
       +
                       }

     

       731
       731
       +
                   } else {

     

       732
       732
       +
                       quote! {}

     

       733
       733
       +
                   };

     

       734
       734
       +
       

     

       735
       735
       +
                   quote! {

     

       736
       736
       +
                       impl jacquard_common::IntoStatic for #ident<'_> {

     

       737
       737
       +
                           type Output = #ident<'static>;

     

       738
       738
       +
       

     

       739
       739
       +
                           fn into_static(self) -> Self::Output {

     

       740
       740
       +
                               match self {

     

       741
       741
       +
                                   #(#variant_conversions,)*

     

       742
       742
       +
                                   #unknown_conversion

     

       743
       743
       +
                               }

     

       744
       744
       +
                           }

     

       745
       745
       +
                       }

     

       746
       746
       +
                   }

     

       747
       747
       +
               } else {

     

       748
       748
       +
                   quote! {

     

       749
       749
       +
                       impl jacquard_common::IntoStatic for #ident {

     

       750
       750
       +
                           type Output = #ident;

     

       751
       751
       +
       

     

       752
       752
       +
                           fn into_static(self) -> Self::Output {

     

       753
       753
       +
                               self

     

       754
       754
       +
                           }

     

       755
       755
       +
                       }

     

       756
       756
       +
                   }

     

       757
       757
       +
               }

     

       758
       758
       +
           }

     

       759
       759
       +
       }

+259

crates/jacquard-lexicon/src/codegen/types.rs

···

       1
       1
       +
       use crate::error::Result;

     

       2
       2
       +
       use crate::lexicon::{LexArrayItem, LexObjectProperty, LexString, LexStringFormat};

     

       3
       3
       +
       use heck::ToSnakeCase;

     

       4
       4
       +
       use proc_macro2::TokenStream;

     

       5
       5
       +
       use quote::quote;

     

       6
       6
       +
       

     

       7
       7
       +
       use super::CodeGenerator;

     

       8
       8
       +
       

     

       9
       9
       +
       impl<'c> CodeGenerator<'c> {

     

       10
       10
       +
           /// Convert a property type to Rust type

     

       11
       11
       +
           pub(super) fn property_to_rust_type(

     

       12
       12
       +
               &self,

     

       13
       13
       +
               nsid: &str,

     

       14
       14
       +
               parent_type_name: &str,

     

       15
       15
       +
               field_name: &str,

     

       16
       16
       +
               prop: &LexObjectProperty<'static>,

     

       17
       17
       +
           ) -> Result<TokenStream> {

     

       18
       18
       +
               match prop {

     

       19
       19
       +
                   LexObjectProperty::Boolean(_) => Ok(quote! { bool }),

     

       20
       20
       +
                   LexObjectProperty::Integer(_) => Ok(quote! { i64 }),

     

       21
       21
       +
                   LexObjectProperty::String(s) => Ok(self.string_to_rust_type(s)),

     

       22
       22
       +
                   LexObjectProperty::Bytes(_) => Ok(quote! { bytes::Bytes }),

     

       23
       23
       +
                   LexObjectProperty::CidLink(_) => {

     

       24
       24
       +
                       Ok(quote! { jacquard_common::types::cid::CidLink<'a> })

     

       25
       25
       +
                   }

     

       26
       26
       +
                   LexObjectProperty::Blob(_) => Ok(quote! { jacquard_common::types::blob::Blob<'a> }),

     

       27
       27
       +
                   LexObjectProperty::Unknown(_) => Ok(quote! { jacquard_common::types::value::Data<'a> }),

     

       28
       28
       +
                   LexObjectProperty::Array(array) => {

     

       29
       29
       +
                       // For arrays with union items, check if multi-variant

     

       30
       30
       +
                       if let LexArrayItem::Union(union) = &array.items {

     

       31
       31
       +
                           if union.refs.is_empty() {

     

       32
       32
       +
                               // Empty union: fall back to Data

     

       33
       33
       +
                               Ok(quote! { Vec<jacquard_common::types::value::Data<'a>> })

     

       34
       34
       +
                           } else if union.refs.len() == 1 {

     

       35
       35
       +
                               // Single-variant: use the ref type directly

     

       36
       36
       +
                               let ref_str = if union.refs[0].starts_with('#') {

     

       37
       37
       +
                                   format!("{}{}", nsid, union.refs[0])

     

       38
       38
       +
                               } else {

     

       39
       39
       +
                                   union.refs[0].to_string()

     

       40
       40
       +
                               };

     

       41
       41
       +
                               let ref_type = self.ref_to_rust_type(&ref_str)?;

     

       42
       42
       +
                               Ok(quote! { Vec<#ref_type> })

     

       43
       43
       +
                           } else {

     

       44
       44
       +
                               // Multi-variant: use generated union type

     

       45
       45
       +
                               let union_name = self.generate_field_type_name(nsid, parent_type_name, field_name, "Item");

     

       46
       46
       +
                               let union_ident = syn::Ident::new(&union_name, proc_macro2::Span::call_site());

     

       47
       47
       +
                               Ok(quote! { Vec<#union_ident<'a>> })

     

       48
       48
       +
                           }

     

       49
       49
       +
                       } else {

     

       50
       50
       +
                           let item_type = self.array_item_to_rust_type(nsid, &array.items)?;

     

       51
       51
       +
                           Ok(quote! { Vec<#item_type> })

     

       52
       52
       +
                       }

     

       53
       53
       +
                   }

     

       54
       54
       +
                   LexObjectProperty::Object(_object) => {

     

       55
       55
       +
                       // Generate unique nested object type name with collision detection

     

       56
       56
       +
                       let object_name = self.generate_field_type_name(nsid, parent_type_name, field_name, "");

     

       57
       57
       +
                       let object_ident = syn::Ident::new(&object_name, proc_macro2::Span::call_site());

     

       58
       58
       +
                       Ok(quote! { #object_ident<'a> })

     

       59
       59
       +
                   }

     

       60
       60
       +
                   LexObjectProperty::Ref(ref_type) => {

     

       61
       61
       +
                       // Handle local refs (starting with #) by prepending the current NSID

     

       62
       62
       +
                       let ref_str = if ref_type.r#ref.starts_with('#') {

     

       63
       63
       +
                           format!("{}{}", nsid, ref_type.r#ref)

     

       64
       64
       +
                       } else {

     

       65
       65
       +
                           ref_type.r#ref.to_string()

     

       66
       66
       +
                       };

     

       67
       67
       +
                       self.ref_to_rust_type(&ref_str)

     

       68
       68
       +
                   }

     

       69
       69
       +
                   LexObjectProperty::Union(union) => {

     

       70
       70
       +
                       if union.refs.is_empty() {

     

       71
       71
       +
                           // Empty union: fall back to Data

     

       72
       72
       +
                           Ok(quote! { jacquard_common::types::value::Data<'a> })

     

       73
       73
       +
                       } else if union.refs.len() == 1 {

     

       74
       74
       +
                           // Check if this is a self-reference

     

       75
       75
       +
                           let ref_str = if union.refs[0].starts_with('#') {

     

       76
       76
       +
                               format!("{}{}", nsid, union.refs[0])

     

       77
       77
       +
                           } else {

     

       78
       78
       +
                               union.refs[0].to_string()

     

       79
       79
       +
                           };

     

       80
       80
       +
       

     

       81
       81
       +
                           // Parse ref to get type name

     

       82
       82
       +
                           let (ref_nsid, ref_def) = if let Some((nsid_part, fragment)) = ref_str.split_once('#') {

     

       83
       83
       +
                               (nsid_part, fragment)

     

       84
       84
       +
                           } else {

     

       85
       85
       +
                               (ref_str.as_str(), "main")

     

       86
       86
       +
                           };

     

       87
       87
       +
                           let ref_type_name = self.def_to_type_name(ref_nsid, ref_def);

     

       88
       88
       +
       

     

       89
       89
       +
                           // If self-referential, keep union for indirection (variants are boxed)

     

       90
       90
       +
                           if ref_type_name == parent_type_name {

     

       91
       91
       +
                               let union_name = self.generate_field_type_name(nsid, parent_type_name, field_name, "");

     

       92
       92
       +
                               let union_ident = syn::Ident::new(&union_name, proc_macro2::Span::call_site());

     

       93
       93
       +
                               Ok(quote! { #union_ident<'a> })

     

       94
       94
       +
                           } else {

     

       95
       95
       +
                               // Non-self-ref single-variant: use the ref type directly

     

       96
       96
       +
                               self.ref_to_rust_type(&ref_str)

     

       97
       97
       +
                           }

     

       98
       98
       +
                       } else {

     

       99
       99
       +
                           // Multi-variant: generate union type with collision detection

     

       100
       100
       +
                           let union_name = self.generate_field_type_name(nsid, parent_type_name, field_name, "");

     

       101
       101
       +
                           let union_ident = syn::Ident::new(&union_name, proc_macro2::Span::call_site());

     

       102
       102
       +
                           Ok(quote! { #union_ident<'a> })

     

       103
       103
       +
                       }

     

       104
       104
       +
                   }

     

       105
       105
       +
               }

     

       106
       106
       +
           }

     

       107
       107
       +
       

     

       108
       108
       +
           /// Convert array item to Rust type

     

       109
       109
       +
           pub(super) fn array_item_to_rust_type(&self, nsid: &str, item: &LexArrayItem) -> Result<TokenStream> {

     

       110
       110
       +
               match item {

     

       111
       111
       +
                   LexArrayItem::Boolean(_) => Ok(quote! { bool }),

     

       112
       112
       +
                   LexArrayItem::Integer(_) => Ok(quote! { i64 }),

     

       113
       113
       +
                   LexArrayItem::String(s) => Ok(self.string_to_rust_type(s)),

     

       114
       114
       +
                   LexArrayItem::Bytes(_) => Ok(quote! { bytes::Bytes }),

     

       115
       115
       +
                   LexArrayItem::CidLink(_) => Ok(quote! { jacquard_common::types::cid::CidLink<'a> }),

     

       116
       116
       +
                   LexArrayItem::Blob(_) => Ok(quote! { jacquard_common::types::blob::Blob<'a> }),

     

       117
       117
       +
                   LexArrayItem::Unknown(_) => Ok(quote! { jacquard_common::types::value::Data<'a> }),

     

       118
       118
       +
                   LexArrayItem::Object(_) => {

     

       119
       119
       +
                       // For inline objects in arrays, use Data since we can't generate a unique type name

     

       120
       120
       +
                       Ok(quote! { jacquard_common::types::value::Data<'a> })

     

       121
       121
       +
                   }

     

       122
       122
       +
                   LexArrayItem::Ref(ref_type) => {

     

       123
       123
       +
                       // Handle local refs (starting with #) by prepending the current NSID

     

       124
       124
       +
                       let ref_str = if ref_type.r#ref.starts_with('#') {

     

       125
       125
       +
                           format!("{}{}", nsid, ref_type.r#ref)

     

       126
       126
       +
                       } else {

     

       127
       127
       +
                           ref_type.r#ref.to_string()

     

       128
       128
       +
                       };

     

       129
       129
       +
                       self.ref_to_rust_type(&ref_str)

     

       130
       130
       +
                   }

     

       131
       131
       +
                   LexArrayItem::Union(_) => {

     

       132
       132
       +
                       // For now, use Data

     

       133
       133
       +
                       Ok(quote! { jacquard_common::types::value::Data<'a> })

     

       134
       134
       +
                   }

     

       135
       135
       +
               }

     

       136
       136
       +
           }

     

       137
       137
       +
       

     

       138
       138
       +
           /// Convert string type to Rust type

     

       139
       139
       +
           pub(super) fn string_to_rust_type(&self, s: &LexString) -> TokenStream {

     

       140
       140
       +
               match s.format {

     

       141
       141
       +
                   Some(LexStringFormat::Datetime) => {

     

       142
       142
       +
                       quote! { jacquard_common::types::string::Datetime }

     

       143
       143
       +
                   }

     

       144
       144
       +
                   Some(LexStringFormat::Did) => quote! { jacquard_common::types::string::Did<'a> },

     

       145
       145
       +
                   Some(LexStringFormat::Handle) => quote! { jacquard_common::types::string::Handle<'a> },

     

       146
       146
       +
                   Some(LexStringFormat::AtIdentifier) => {

     

       147
       147
       +
                       quote! { jacquard_common::types::ident::AtIdentifier<'a> }

     

       148
       148
       +
                   }

     

       149
       149
       +
                   Some(LexStringFormat::Nsid) => quote! { jacquard_common::types::string::Nsid<'a> },

     

       150
       150
       +
                   Some(LexStringFormat::AtUri) => quote! { jacquard_common::types::string::AtUri<'a> },

     

       151
       151
       +
                   Some(LexStringFormat::Uri) => quote! { jacquard_common::types::string::Uri<'a> },

     

       152
       152
       +
                   Some(LexStringFormat::Cid) => quote! { jacquard_common::types::string::Cid<'a> },

     

       153
       153
       +
                   Some(LexStringFormat::Language) => {

     

       154
       154
       +
                       quote! { jacquard_common::types::string::Language }

     

       155
       155
       +
                   }

     

       156
       156
       +
                   Some(LexStringFormat::Tid) => quote! { jacquard_common::types::string::Tid },

     

       157
       157
       +
                   Some(LexStringFormat::RecordKey) => {

     

       158
       158
       +
                       quote! { jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>> }

     

       159
       159
       +
                   }

     

       160
       160
       +
                   _ => quote! { jacquard_common::CowStr<'a> },

     

       161
       161
       +
               }

     

       162
       162
       +
           }

     

       163
       163
       +
       

     

       164
       164
       +
           /// Convert ref to Rust type path

     

       165
       165
       +
           pub(super) fn ref_to_rust_type(&self, ref_str: &str) -> Result<TokenStream> {

     

       166
       166
       +
               use crate::error::CodegenError;

     

       167
       167
       +
               use super::utils::sanitize_name;

     

       168
       168
       +
       

     

       169
       169
       +
               // Parse NSID and fragment

     

       170
       170
       +
               let (ref_nsid, ref_def) = if let Some((nsid, fragment)) = ref_str.split_once('#') {

     

       171
       171
       +
                   (nsid, fragment)

     

       172
       172
       +
               } else {

     

       173
       173
       +
                   (ref_str, "main")

     

       174
       174
       +
               };

     

       175
       175
       +
       

     

       176
       176
       +
               // Check if ref exists

     

       177
       177
       +
               if !self.corpus.ref_exists(ref_str) {

     

       178
       178
       +
                   // Fallback to Data

     

       179
       179
       +
                   return Ok(quote! { jacquard_common::types::value::Data<'a> });

     

       180
       180
       +
               }

     

       181
       181
       +
       

     

       182
       182
       +
               // Convert NSID to module path

     

       183
       183
       +
               // com.atproto.repo.strongRef -> com_atproto::repo::strong_ref::StrongRef

     

       184
       184
       +
               // app.bsky.richtext.facet -> app_bsky::richtext::facet::Facet

     

       185
       185
       +
               // app.bsky.actor.defs#nux -> app_bsky::actor::Nux (defs go in parent module)

     

       186
       186
       +
               let parts: Vec<&str> = ref_nsid.split('.').collect();

     

       187
       187
       +
               let last_segment = parts.last().unwrap();

     

       188
       188
       +
       

     

       189
       189
       +
               let type_name = self.def_to_type_name(ref_nsid, ref_def);

     

       190
       190
       +
       

     

       191
       191
       +
               let path_str = if *last_segment == "defs" && parts.len() >= 3 {

     

       192
       192
       +
                   // defs types go in parent module

     

       193
       193
       +
                   let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1]));

     

       194
       194
       +
                   if parts.len() == 3 {

     

       195
       195
       +
                       // com.atproto.defs -> com_atproto::TypeName

     

       196
       196
       +
                       format!("{}::{}::{}", self.root_module, first_two, type_name)

     

       197
       197
       +
                   } else {

     

       198
       198
       +
                       // app.bsky.actor.defs -> app_bsky::actor::TypeName

     

       199
       199
       +
                       let middle: Vec<_> = parts[2..parts.len() - 1]

     

       200
       200
       +
                           .iter()

     

       201
       201
       +
                           .copied()

     

       202
       202
       +
                           .map(|s| sanitize_name(s))

     

       203
       203
       +
                           .collect();

     

       204
       204
       +
                       format!(

     

       205
       205
       +
                           "{}::{}::{}::{}",

     

       206
       206
       +
                           self.root_module,

     

       207
       207
       +
                           first_two,

     

       208
       208
       +
                           middle.join("::"),

     

       209
       209
       +
                           type_name

     

       210
       210
       +
                       )

     

       211
       211
       +
                   }

     

       212
       212
       +
               } else {

     

       213
       213
       +
                   // Regular types go in their own module file

     

       214
       214
       +
                   let (module_path, file_module) = if parts.len() >= 3 {

     

       215
       215
       +
                       // Join first two segments with underscore

     

       216
       216
       +
                       let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1]));

     

       217
       217
       +
                       let file_name = sanitize_name(last_segment).to_snake_case();

     

       218
       218
       +
       

     

       219
       219
       +
                       if parts.len() > 3 {

     

       220
       220
       +
                           // Middle segments form the module path

     

       221
       221
       +
                           let middle: Vec<_> = parts[2..parts.len() - 1]

     

       222
       222
       +
                               .iter()

     

       223
       223
       +
                               .copied()

     

       224
       224
       +
                               .map(|s| sanitize_name(s))

     

       225
       225
       +
                               .collect();

     

       226
       226
       +
                           let base_path = format!("{}::{}", first_two, middle.join("::"));

     

       227
       227
       +
                           (base_path, file_name)

     

       228
       228
       +
                       } else {

     

       229
       229
       +
                           // Only 3 parts: com.atproto.label -> com_atproto, file: label

     

       230
       230
       +
                           (first_two, file_name)

     

       231
       231
       +
                       }

     

       232
       232
       +
                   } else if parts.len() == 2 {

     

       233
       233
       +
                       // e.g., "com.example" -> "com_example", file: example

     

       234
       234
       +
                       let first = sanitize_name(parts[0]);

     

       235
       235
       +
                       let file_name = sanitize_name(parts[1]).to_snake_case();

     

       236
       236
       +
                       (first, file_name)

     

       237
       237
       +
                   } else {

     

       238
       238
       +
                       (parts[0].to_string(), "main".to_string())

     

       239
       239
       +
                   };

     

       240
       240
       +
       

     

       241
       241
       +
                   format!(

     

       242
       242
       +
                       "{}::{}::{}::{}",

     

       243
       243
       +
                       self.root_module, module_path, file_module, type_name

     

       244
       244
       +
                   )

     

       245
       245
       +
               };

     

       246
       246
       +
       

     

       247
       247
       +
               let path: syn::Path = syn::parse_str(&path_str).map_err(|e| CodegenError::Other {

     

       248
       248
       +
                   message: format!("Failed to parse path: {} {}", path_str, e),

     

       249
       249
       +
                   source: None,

     

       250
       250
       +
               })?;

     

       251
       251
       +
       

     

       252
       252
       +
               // Only add lifetime if the target type needs it

     

       253
       253
       +
               if self.ref_needs_lifetime(ref_str) {

     

       254
       254
       +
                   Ok(quote! { #path<'a> })

     

       255
       255
       +
               } else {

     

       256
       256
       +
                   Ok(quote! { #path })

     

       257
       257
       +
               }

     

       258
       258
       +
           }

     

       259
       259
       +
       }

+81

crates/jacquard-lexicon/src/codegen/utils.rs

···

       1
       1
       +
       use heck::ToPascalCase;

     

       2
       2
       +
       use jacquard_common::CowStr;

     

       3
       3
       +
       use proc_macro2::TokenStream;

     

       4
       4
       +
       use quote::quote;

     

       5
       5
       +
       

     

       6
       6
       +
       /// Convert a value string to a valid Rust variant name

     

       7
       7
       +
       pub(super) fn value_to_variant_name(value: &str) -> String {

     

       8
       8
       +
           // Remove leading special chars and convert to pascal case

     

       9
       9
       +
           let clean = value.trim_start_matches(|c: char| !c.is_alphanumeric());

     

       10
       10
       +
           let variant = clean.replace('-', "_").to_pascal_case();

     

       11
       11
       +
       

     

       12
       12
       +
           // Prefix with underscore if starts with digit

     

       13
       13
       +
           if variant.chars().next().map_or(false, |c| c.is_ascii_digit()) {

     

       14
       14
       +
               format!("_{}", variant)

     

       15
       15
       +
           } else if variant.is_empty() {

     

       16
       16
       +
               "Unknown".to_string()

     

       17
       17
       +
           } else {

     

       18
       18
       +
               variant

     

       19
       19
       +
           }

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       /// Sanitize a string to be safe for identifiers and filenames

     

       23
       23
       +
       pub(super) fn sanitize_name(s: &str) -> String {

     

       24
       24
       +
           if s.is_empty() {

     

       25
       25
       +
               return "unknown".to_string();

     

       26
       26
       +
           }

     

       27
       27
       +
       

     

       28
       28
       +
           // Replace invalid characters with underscores

     

       29
       29
       +
           let mut sanitized: String = s

     

       30
       30
       +
               .chars()

     

       31
       31
       +
               .map(|c| {

     

       32
       32
       +
                   if c.is_alphanumeric() || c == '_' {

     

       33
       33
       +
                       c

     

       34
       34
       +
                   } else {

     

       35
       35
       +
                       '_'

     

       36
       36
       +
                   }

     

       37
       37
       +
               })

     

       38
       38
       +
               .collect();

     

       39
       39
       +
       

     

       40
       40
       +
           // Ensure it doesn't start with a digit

     

       41
       41
       +
           if sanitized

     

       42
       42
       +
               .chars()

     

       43
       43
       +
               .next()

     

       44
       44
       +
               .map_or(false, |c| c.is_ascii_digit())

     

       45
       45
       +
           {

     

       46
       46
       +
               sanitized = format!("_{}", sanitized);

     

       47
       47
       +
           }

     

       48
       48
       +
       

     

       49
       49
       +
           sanitized

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       /// Create an identifier, using raw identifier if necessary for keywords

     

       53
       53
       +
       pub(super) fn make_ident(s: &str) -> syn::Ident {

     

       54
       54
       +
           if s.is_empty() {

     

       55
       55
       +
               eprintln!("Warning: Empty identifier encountered, using 'unknown' as fallback");

     

       56
       56
       +
               return syn::Ident::new("unknown", proc_macro2::Span::call_site());

     

       57
       57
       +
           }

     

       58
       58
       +
       

     

       59
       59
       +
           let sanitized = sanitize_name(s);

     

       60
       60
       +
       

     

       61
       61
       +
           // Try to parse as ident, fall back to raw ident if needed

     

       62
       62
       +
           syn::parse_str::<syn::Ident>(&sanitized).unwrap_or_else(|_| {

     

       63
       63
       +
               eprintln!(

     

       64
       64
       +
                   "Warning: Invalid identifier '{}' sanitized to '{}'",

     

       65
       65
       +
                   s, sanitized

     

       66
       66
       +
               );

     

       67
       67
       +
               syn::Ident::new_raw(&sanitized, proc_macro2::Span::call_site())

     

       68
       68
       +
           })

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       /// Generate doc comment from optional description

     

       72
       72
       +
       pub(super) fn generate_doc_comment(desc: Option<&CowStr>) -> TokenStream {

     

       73
       73
       +
           if let Some(description) = desc {

     

       74
       74
       +
               let desc_str = description.as_ref();

     

       75
       75
       +
               quote! {

     

       76
       76
       +
                   #[doc = #desc_str]

     

       77
       77
       +
               }

     

       78
       78
       +
           } else {

     

       79
       79
       +
               quote! {}

     

       80
       80
       +
           }

     

       81
       81
       +
       }

+1006

crates/jacquard-lexicon/src/codegen/xrpc.rs

···

       1
       1
       +
       use crate::error::Result;

     

       2
       2
       +
       use crate::lexicon::{

     

       3
       3
       +
           LexArrayItem, LexObjectProperty, LexXrpcBody, LexXrpcBodySchema, LexXrpcError,

     

       4
       4
       +
           LexXrpcProcedure, LexXrpcQuery, LexXrpcSubscription, LexXrpcSubscriptionMessageSchema,

     

       5
       5
       +
       };

     

       6
       6
       +
       use heck::{ToPascalCase, ToSnakeCase};

     

       7
       7
       +
       use proc_macro2::TokenStream;

     

       8
       8
       +
       use quote::quote;

     

       9
       9
       +
       

     

       10
       10
       +
       use super::utils::make_ident;

     

       11
       11
       +
       use super::CodeGenerator;

     

       12
       12
       +
       

     

       13
       13
       +
       impl<'c> CodeGenerator<'c> {

     

       14
       14
       +
           /// Generate query type

     

       15
       15
       +
           pub(super) fn generate_query(

     

       16
       16
       +
               &self,

     

       17
       17
       +
               nsid: &str,

     

       18
       18
       +
               def_name: &str,

     

       19
       19
       +
               query: &LexXrpcQuery<'static>,

     

       20
       20
       +
           ) -> Result<TokenStream> {

     

       21
       21
       +
               let type_base = self.def_to_type_name(nsid, def_name);

     

       22
       22
       +
               let mut output = Vec::new();

     

       23
       23
       +
       

     

       24
       24
       +
               let params_has_lifetime = query

     

       25
       25
       +
                   .parameters

     

       26
       26
       +
                   .as_ref()

     

       27
       27
       +
                   .map(|p| match p {

     

       28
       28
       +
                       crate::lexicon::LexXrpcQueryParameter::Params(params) => {

     

       29
       29
       +
                           self.params_need_lifetime(params)

     

       30
       30
       +
                       }

     

       31
       31
       +
                   })

     

       32
       32
       +
                   .unwrap_or(false);

     

       33
       33
       +
               let has_params = query.parameters.is_some();

     

       34
       34
       +
               let has_output = query.output.is_some();

     

       35
       35
       +
               let has_errors = query.errors.is_some();

     

       36
       36
       +
       

     

       37
       37
       +
               if let Some(params) = &query.parameters {

     

       38
       38
       +
                   let params_struct = self.generate_params_struct(&type_base, params)?;

     

       39
       39
       +
                   output.push(params_struct);

     

       40
       40
       +
               }

     

       41
       41
       +
       

     

       42
       42
       +
               if let Some(body) = &query.output {

     

       43
       43
       +
                   let output_struct = self.generate_output_struct(nsid, &type_base, body)?;

     

       44
       44
       +
                   output.push(output_struct);

     

       45
       45
       +
               }

     

       46
       46
       +
       

     

       47
       47
       +
               if let Some(errors) = &query.errors {

     

       48
       48
       +
                   let error_enum = self.generate_error_enum(&type_base, errors)?;

     

       49
       49
       +
                   output.push(error_enum);

     

       50
       50
       +
               }

     

       51
       51
       +
       

     

       52
       52
       +
               // Generate XrpcRequest impl

     

       53
       53
       +
               let output_encoding = query

     

       54
       54
       +
                   .output

     

       55
       55
       +
                   .as_ref()

     

       56
       56
       +
                   .map(|o| o.encoding.as_ref())

     

       57
       57
       +
                   .unwrap_or("application/json");

     

       58
       58
       +
               let xrpc_impl = self.generate_xrpc_request_impl(

     

       59
       59
       +
                   nsid,

     

       60
       60
       +
                   &type_base,

     

       61
       61
       +
                   quote! { jacquard_common::xrpc::XrpcMethod::Query },

     

       62
       62
       +
                   output_encoding,

     

       63
       63
       +
                   has_params,

     

       64
       64
       +
                   params_has_lifetime,

     

       65
       65
       +
                   has_output,

     

       66
       66
       +
                   has_errors,

     

       67
       67
       +
                   false, // queries never have binary inputs

     

       68
       68
       +
               )?;

     

       69
       69
       +
               output.push(xrpc_impl);

     

       70
       70
       +
       

     

       71
       71
       +
               Ok(quote! {

     

       72
       72
       +
                   #(#output)*

     

       73
       73
       +
               })

     

       74
       74
       +
           }

     

       75
       75
       +
       

     

       76
       76
       +
           /// Generate procedure type

     

       77
       77
       +
           pub(super) fn generate_procedure(

     

       78
       78
       +
               &self,

     

       79
       79
       +
               nsid: &str,

     

       80
       80
       +
               def_name: &str,

     

       81
       81
       +
               proc: &LexXrpcProcedure<'static>,

     

       82
       82
       +
           ) -> Result<TokenStream> {

     

       83
       83
       +
               let type_base = self.def_to_type_name(nsid, def_name);

     

       84
       84
       +
               let mut output = Vec::new();

     

       85
       85
       +
       

     

       86
       86
       +
               // Check if input is a binary body (no schema)

     

       87
       87
       +
               let is_binary_input = proc

     

       88
       88
       +
                   .input

     

       89
       89
       +
                   .as_ref()

     

       90
       90
       +
                   .map(|i| i.schema.is_none())

     

       91
       91
       +
                   .unwrap_or(false);

     

       92
       92
       +
       

     

       93
       93
       +
               // Input bodies with schemas have lifetimes (they get #[lexicon] attribute)

     

       94
       94
       +
               // Binary inputs don't have lifetimes

     

       95
       95
       +
               let params_has_lifetime = proc.input.is_some() && !is_binary_input;

     

       96
       96
       +
               let has_input = proc.input.is_some();

     

       97
       97
       +
               let has_output = proc.output.is_some();

     

       98
       98
       +
               let has_errors = proc.errors.is_some();

     

       99
       99
       +
       

     

       100
       100
       +
               if let Some(params) = &proc.parameters {

     

       101
       101
       +
                   let params_struct = self.generate_params_struct_proc(&type_base, params)?;

     

       102
       102
       +
                   output.push(params_struct);

     

       103
       103
       +
               }

     

       104
       104
       +
       

     

       105
       105
       +
               if let Some(body) = &proc.input {

     

       106
       106
       +
                   let input_struct = self.generate_input_struct(nsid, &type_base, body)?;

     

       107
       107
       +
                   output.push(input_struct);

     

       108
       108
       +
               }

     

       109
       109
       +
       

     

       110
       110
       +
               if let Some(body) = &proc.output {

     

       111
       111
       +
                   let output_struct = self.generate_output_struct(nsid, &type_base, body)?;

     

       112
       112
       +
                   output.push(output_struct);

     

       113
       113
       +
               }

     

       114
       114
       +
       

     

       115
       115
       +
               if let Some(errors) = &proc.errors {

     

       116
       116
       +
                   let error_enum = self.generate_error_enum(&type_base, errors)?;

     

       117
       117
       +
                   output.push(error_enum);

     

       118
       118
       +
               }

     

       119
       119
       +
       

     

       120
       120
       +
               // Generate XrpcRequest impl

     

       121
       121
       +
               let input_encoding = proc

     

       122
       122
       +
                   .input

     

       123
       123
       +
                   .as_ref()

     

       124
       124
       +
                   .map(|i| i.encoding.as_ref())

     

       125
       125
       +
                   .unwrap_or("application/json");

     

       126
       126
       +
               let output_encoding = proc

     

       127
       127
       +
                   .output

     

       128
       128
       +
                   .as_ref()

     

       129
       129
       +
                   .map(|o| o.encoding.as_ref())

     

       130
       130
       +
                   .unwrap_or("application/json");

     

       131
       131
       +
               let xrpc_impl = self.generate_xrpc_request_impl(

     

       132
       132
       +
                   nsid,

     

       133
       133
       +
                   &type_base,

     

       134
       134
       +
                   quote! { jacquard_common::xrpc::XrpcMethod::Procedure(#input_encoding) },

     

       135
       135
       +
                   output_encoding,

     

       136
       136
       +
                   has_input,

     

       137
       137
       +
                   params_has_lifetime,

     

       138
       138
       +
                   has_output,

     

       139
       139
       +
                   has_errors,

     

       140
       140
       +
                   is_binary_input,

     

       141
       141
       +
               )?;

     

       142
       142
       +
               output.push(xrpc_impl);

     

       143
       143
       +
       

     

       144
       144
       +
               Ok(quote! {

     

       145
       145
       +
                   #(#output)*

     

       146
       146
       +
               })

     

       147
       147
       +
           }

     

       148
       148
       +
       

     

       149
       149
       +
           pub(super) fn generate_subscription(

     

       150
       150
       +
               &self,

     

       151
       151
       +
               nsid: &str,

     

       152
       152
       +
               def_name: &str,

     

       153
       153
       +
               sub: &LexXrpcSubscription<'static>,

     

       154
       154
       +
           ) -> Result<TokenStream> {

     

       155
       155
       +
               let type_base = self.def_to_type_name(nsid, def_name);

     

       156
       156
       +
               let mut output = Vec::new();

     

       157
       157
       +
       

     

       158
       158
       +
               if let Some(params) = &sub.parameters {

     

       159
       159
       +
                   // Extract LexXrpcParameters from the enum

     

       160
       160
       +
                   match params {

     

       161
       161
       +
                       crate::lexicon::LexXrpcSubscriptionParameter::Params(params_inner) => {

     

       162
       162
       +
                           let params_struct =

     

       163
       163
       +
                               self.generate_params_struct_inner(&type_base, params_inner)?;

     

       164
       164
       +
                           output.push(params_struct);

     

       165
       165
       +
                       }

     

       166
       166
       +
                   }

     

       167
       167
       +
               }

     

       168
       168
       +
       

     

       169
       169
       +
               if let Some(message) = &sub.message {

     

       170
       170
       +
                   if let Some(schema) = &message.schema {

     

       171
       171
       +
                       let message_type = self.generate_subscription_message(nsid, &type_base, schema)?;

     

       172
       172
       +
                       output.push(message_type);

     

       173
       173
       +
                   }

     

       174
       174
       +
               }

     

       175
       175
       +
       

     

       176
       176
       +
               if let Some(errors) = &sub.errors {

     

       177
       177
       +
                   let error_enum = self.generate_error_enum(&type_base, errors)?;

     

       178
       178
       +
                   output.push(error_enum);

     

       179
       179
       +
               }

     

       180
       180
       +
       

     

       181
       181
       +
               Ok(quote! {

     

       182
       182
       +
                   #(#output)*

     

       183
       183
       +
               })

     

       184
       184
       +
           }

     

       185
       185
       +
       

     

       186
       186
       +
           pub(super) fn generate_subscription_message(

     

       187
       187
       +
               &self,

     

       188
       188
       +
               nsid: &str,

     

       189
       189
       +
               type_base: &str,

     

       190
       190
       +
               schema: &LexXrpcSubscriptionMessageSchema<'static>,

     

       191
       191
       +
           ) -> Result<TokenStream> {

     

       192
       192
       +
               use crate::lexicon::LexXrpcSubscriptionMessageSchema;

     

       193
       193
       +
       

     

       194
       194
       +
               match schema {

     

       195
       195
       +
                   LexXrpcSubscriptionMessageSchema::Union(union) => {

     

       196
       196
       +
                       // Generate a union enum for the message

     

       197
       197
       +
                       let enum_name = format!("{}Message", type_base);

     

       198
       198
       +
                       let enum_ident = syn::Ident::new(&enum_name, proc_macro2::Span::call_site());

     

       199
       199
       +
       

     

       200
       200
       +
                       let mut variants = Vec::new();

     

       201
       201
       +
                       for ref_str in &union.refs {

     

       202
       202
       +
                           let ref_str_s = ref_str.as_ref();

     

       203
       203
       +
                           // Parse ref to get NSID and def name

     

       204
       204
       +
                           let (ref_nsid, ref_def) =

     

       205
       205
       +
                               if let Some((nsid, fragment)) = ref_str.split_once('#') {

     

       206
       206
       +
                                   (nsid, fragment)

     

       207
       207
       +
                               } else {

     

       208
       208
       +
                                   (ref_str.as_ref(), "main")

     

       209
       209
       +
                               };

     

       210
       210
       +
       

     

       211
       211
       +
                           let variant_name = if ref_def == "main" {

     

       212
       212
       +
                               ref_nsid.split('.').last().unwrap().to_pascal_case()

     

       213
       213
       +
                           } else {

     

       214
       214
       +
                               ref_def.to_pascal_case()

     

       215
       215
       +
                           };

     

       216
       216
       +
                           let variant_ident =

     

       217
       217
       +
                               syn::Ident::new(&variant_name, proc_macro2::Span::call_site());

     

       218
       218
       +
                           let type_path = self.ref_to_rust_type(ref_str)?;

     

       219
       219
       +
       

     

       220
       220
       +
                           variants.push(quote! {

     

       221
       221
       +
                               #[serde(rename = #ref_str_s)]

     

       222
       222
       +
                               #variant_ident(Box<#type_path>)

     

       223
       223
       +
                           });

     

       224
       224
       +
                       }

     

       225
       225
       +
       

     

       226
       226
       +
                       let doc = self.generate_doc_comment(union.description.as_ref());

     

       227
       227
       +
       

     

       228
       228
       +
                       Ok(quote! {

     

       229
       229
       +
                           #doc

     

       230
       230
       +
                           #[jacquard_derive::open_union]

     

       231
       231
       +
                           #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       232
       232
       +
                           #[serde(tag = "$type")]

     

       233
       233
       +
                           #[serde(bound(deserialize = "'de: 'a"))]

     

       234
       234
       +
                           pub enum #enum_ident<'a> {

     

       235
       235
       +
                               #(#variants,)*

     

       236
       236
       +
                           }

     

       237
       237
       +
                       })

     

       238
       238
       +
                   }

     

       239
       239
       +
                   LexXrpcSubscriptionMessageSchema::Object(obj) => {

     

       240
       240
       +
                       // Generate a struct for the message

     

       241
       241
       +
                       let struct_name = format!("{}Message", type_base);

     

       242
       242
       +
                       let struct_ident = syn::Ident::new(&struct_name, proc_macro2::Span::call_site());

     

       243
       243
       +
       

     

       244
       244
       +
                       let fields = self.generate_object_fields("", &struct_name, obj, false)?;

     

       245
       245
       +
                       let doc = self.generate_doc_comment(obj.description.as_ref());

     

       246
       246
       +
       

     

       247
       247
       +
                       // Subscription message structs always get a lifetime since they have the #[lexicon] attribute

     

       248
       248
       +
                       // which adds extra_data: BTreeMap<..., Data<'a>>

     

       249
       249
       +
                       let struct_def = quote! {

     

       250
       250
       +
                           #doc

     

       251
       251
       +
                           #[jacquard_derive::lexicon]

     

       252
       252
       +
                           #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       253
       253
       +
                           #[serde(rename_all = "camelCase")]

     

       254
       254
       +
                           pub struct #struct_ident<'a> {

     

       255
       255
       +
                               #fields

     

       256
       256
       +
                           }

     

       257
       257
       +
                       };

     

       258
       258
       +
       

     

       259
       259
       +
                       // Generate union types for this message

     

       260
       260
       +
                       let mut unions = Vec::new();

     

       261
       261
       +
                       for (field_name, field_type) in &obj.properties {

     

       262
       262
       +
                           match field_type {

     

       263
       263
       +
                               LexObjectProperty::Union(union) => {

     

       264
       264
       +
                                   // Skip empty, single-variant unions unless they're self-referential

     

       265
       265
       +
                                   if !union.refs.is_empty() && (union.refs.len() > 1 || self.is_self_referential_union(nsid, &struct_name, union)) {

     

       266
       266
       +
                                       let union_name = self.generate_field_type_name(nsid, &struct_name, field_name, "");

     

       267
       267
       +
                                       let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       268
       268
       +
                                       let union_def =

     

       269
       269
       +
                                           self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       270
       270
       +
                                       unions.push(union_def);

     

       271
       271
       +
                                   }

     

       272
       272
       +
                               }

     

       273
       273
       +
                               LexObjectProperty::Array(array) => {

     

       274
       274
       +
                                   if let LexArrayItem::Union(union) = &array.items {

     

       275
       275
       +
                                       // Skip single-variant array unions

     

       276
       276
       +
                                       if union.refs.len() > 1 {

     

       277
       277
       +
                                           let union_name = self.generate_field_type_name(nsid, &struct_name, field_name, "Item");

     

       278
       278
       +
                                           let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       279
       279
       +
                                           let union_def = self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       280
       280
       +
                                           unions.push(union_def);

     

       281
       281
       +
                                       }

     

       282
       282
       +
                                   }

     

       283
       283
       +
                               }

     

       284
       284
       +
                               _ => {}

     

       285
       285
       +
                           }

     

       286
       286
       +
                       }

     

       287
       287
       +
       

     

       288
       288
       +
                       Ok(quote! {

     

       289
       289
       +
                           #struct_def

     

       290
       290
       +
                           #(#unions)*

     

       291
       291
       +
                       })

     

       292
       292
       +
                   }

     

       293
       293
       +
                   LexXrpcSubscriptionMessageSchema::Ref(ref_type) => {

     

       294
       294
       +
                       // Just a type alias to the referenced type

     

       295
       295
       +
                       // Refs generally have lifetimes, so always add <'a>

     

       296
       296
       +
                       let type_name = format!("{}Message", type_base);

     

       297
       297
       +
                       let ident = syn::Ident::new(&type_name, proc_macro2::Span::call_site());

     

       298
       298
       +
                       let rust_type = self.ref_to_rust_type(&ref_type.r#ref)?;

     

       299
       299
       +
                       let doc = self.generate_doc_comment(ref_type.description.as_ref());

     

       300
       300
       +
       

     

       301
       301
       +
                       Ok(quote! {

     

       302
       302
       +
                           #doc

     

       303
       303
       +
                           pub type #ident<'a> = #rust_type;

     

       304
       304
       +
                       })

     

       305
       305
       +
                   }

     

       306
       306
       +
               }

     

       307
       307
       +
           }

     

       308
       308
       +
       

     

       309
       309
       +
           /// Generate params struct from XRPC query parameters

     

       310
       310
       +
           pub(super) fn generate_params_struct(

     

       311
       311
       +
               &self,

     

       312
       312
       +
               type_base: &str,

     

       313
       313
       +
               params: &crate::lexicon::LexXrpcQueryParameter<'static>,

     

       314
       314
       +
           ) -> Result<TokenStream> {

     

       315
       315
       +
               use crate::lexicon::LexXrpcQueryParameter;

     

       316
       316
       +
               match params {

     

       317
       317
       +
                   LexXrpcQueryParameter::Params(p) => self.generate_params_struct_inner(type_base, p),

     

       318
       318
       +
               }

     

       319
       319
       +
           }

     

       320
       320
       +
       

     

       321
       321
       +
           /// Generate params struct from XRPC procedure parameters (query string params)

     

       322
       322
       +
           pub(super) fn generate_params_struct_proc(

     

       323
       323
       +
               &self,

     

       324
       324
       +
               type_base: &str,

     

       325
       325
       +
               params: &crate::lexicon::LexXrpcProcedureParameter<'static>,

     

       326
       326
       +
           ) -> Result<TokenStream> {

     

       327
       327
       +
               use crate::lexicon::LexXrpcProcedureParameter;

     

       328
       328
       +
               match params {

     

       329
       329
       +
                   // For procedures, query string params still get "Params" suffix since the main struct is the input

     

       330
       330
       +
                   LexXrpcProcedureParameter::Params(p) => {

     

       331
       331
       +
                       let struct_name = format!("{}Params", type_base);

     

       332
       332
       +
                       let ident = syn::Ident::new(&struct_name, proc_macro2::Span::call_site());

     

       333
       333
       +
                       self.generate_params_struct_inner_with_name(&ident, p)

     

       334
       334
       +
                   }

     

       335
       335
       +
               }

     

       336
       336
       +
           }

     

       337
       337
       +
       

     

       338
       338
       +
           /// Generate params struct inner (shared implementation)

     

       339
       339
       +
           pub(super) fn generate_params_struct_inner(

     

       340
       340
       +
               &self,

     

       341
       341
       +
               type_base: &str,

     

       342
       342
       +
               p: &crate::lexicon::LexXrpcParameters<'static>,

     

       343
       343
       +
           ) -> Result<TokenStream> {

     

       344
       344
       +
               let ident = syn::Ident::new(type_base, proc_macro2::Span::call_site());

     

       345
       345
       +
               self.generate_params_struct_inner_with_name(&ident, p)

     

       346
       346
       +
           }

     

       347
       347
       +
       

     

       348
       348
       +
           /// Generate params struct with custom name

     

       349
       349
       +
           pub(super) fn generate_params_struct_inner_with_name(

     

       350
       350
       +
               &self,

     

       351
       351
       +
               ident: &syn::Ident,

     

       352
       352
       +
               p: &crate::lexicon::LexXrpcParameters<'static>,

     

       353
       353
       +
           ) -> Result<TokenStream> {

     

       354
       354
       +
               let required = p.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]);

     

       355
       355
       +
               let mut fields = Vec::new();

     

       356
       356
       +
               let mut default_fns = Vec::new();

     

       357
       357
       +
       

     

       358
       358
       +
               for (field_name, field_type) in &p.properties {

     

       359
       359
       +
                   let is_required = required.contains(field_name);

     

       360
       360
       +
                   let (field_tokens, default_fn) =

     

       361
       361
       +
                       self.generate_param_field_with_default("", field_name, field_type, is_required)?;

     

       362
       362
       +
                   fields.push(field_tokens);

     

       363
       363
       +
                   if let Some(fn_def) = default_fn {

     

       364
       364
       +
                       default_fns.push(fn_def);

     

       365
       365
       +
                   }

     

       366
       366
       +
               }

     

       367
       367
       +
       

     

       368
       368
       +
               let doc = self.generate_doc_comment(p.description.as_ref());

     

       369
       369
       +
               let needs_lifetime = self.params_need_lifetime(p);

     

       370
       370
       +
       

     

       371
       371
       +
               let derives = quote! {

     

       372
       372
       +
                   #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder, jacquard_derive::IntoStatic)]

     

       373
       373
       +
                   #[builder(start_fn = new)]

     

       374
       374
       +
               };

     

       375
       375
       +
       

     

       376
       376
       +
               if needs_lifetime {

     

       377
       377
       +
                   Ok(quote! {

     

       378
       378
       +
                       #(#default_fns)*

     

       379
       379
       +
       

     

       380
       380
       +
                       #doc

     

       381
       381
       +
                       #derives

     

       382
       382
       +
                       #[serde(rename_all = "camelCase")]

     

       383
       383
       +
                       pub struct #ident<'a> {

     

       384
       384
       +
                           #(#fields)*

     

       385
       385
       +
                       }

     

       386
       386
       +
                   })

     

       387
       387
       +
               } else {

     

       388
       388
       +
                   Ok(quote! {

     

       389
       389
       +
                       #(#default_fns)*

     

       390
       390
       +
       

     

       391
       391
       +
                       #doc

     

       392
       392
       +
                       #derives

     

       393
       393
       +
                       #[serde(rename_all = "camelCase")]

     

       394
       394
       +
                       pub struct #ident {

     

       395
       395
       +
                           #(#fields)*

     

       396
       396
       +
                       }

     

       397
       397
       +
                   })

     

       398
       398
       +
               }

     

       399
       399
       +
           }

     

       400
       400
       +
       

     

       401
       401
       +
           /// Generate input struct from XRPC body

     

       402
       402
       +
           pub(super) fn generate_input_struct(

     

       403
       403
       +
               &self,

     

       404
       404
       +
               nsid: &str,

     

       405
       405
       +
               type_base: &str,

     

       406
       406
       +
               body: &LexXrpcBody<'static>,

     

       407
       407
       +
           ) -> Result<TokenStream> {

     

       408
       408
       +
               let ident = syn::Ident::new(type_base, proc_macro2::Span::call_site());

     

       409
       409
       +
       

     

       410
       410
       +
               // Check if this is a binary body (no schema, just raw bytes)

     

       411
       411
       +
               let is_binary_body = body.schema.is_none();

     

       412
       412
       +
       

     

       413
       413
       +
               let fields = if let Some(schema) = &body.schema {

     

       414
       414
       +
                   self.generate_body_fields("", type_base, schema, true)?

     

       415
       415
       +
               } else {

     

       416
       416
       +
                   // Binary body: just a bytes field

     

       417
       417
       +
                   quote! {

     

       418
       418
       +
                       pub body: bytes::Bytes,

     

       419
       419
       +
                   }

     

       420
       420
       +
               };

     

       421
       421
       +
       

     

       422
       422
       +
               let doc = self.generate_doc_comment(body.description.as_ref());

     

       423
       423
       +
       

     

       424
       424
       +
               // Binary bodies don't need #[lexicon] attribute or lifetime

     

       425
       425
       +
               let struct_def = if is_binary_body {

     

       426
       426
       +
                   quote! {

     

       427
       427
       +
                       #doc

     

       428
       428
       +
                       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder, jacquard_derive::IntoStatic)]

     

       429
       429
       +
                       #[builder(start_fn = new)]

     

       430
       430
       +
                       #[serde(rename_all = "camelCase")]

     

       431
       431
       +
                       pub struct #ident {

     

       432
       432
       +
                           #fields

     

       433
       433
       +
                       }

     

       434
       434
       +
                   }

     

       435
       435
       +
               } else {

     

       436
       436
       +
                   // Input structs with schemas: manually add extra_data field with #[builder(default)]

     

       437
       437
       +
                   // for bon compatibility. The #[lexicon] macro will see it exists and skip adding it.

     

       438
       438
       +
                   quote! {

     

       439
       439
       +
                       #doc

     

       440
       440
       +
                       #[jacquard_derive::lexicon]

     

       441
       441
       +
                       #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder, jacquard_derive::IntoStatic)]

     

       442
       442
       +
                       #[serde(rename_all = "camelCase")]

     

       443
       443
       +
                       #[builder(start_fn = new)]

     

       444
       444
       +
                       pub struct #ident<'a> {

     

       445
       445
       +
                           #fields

     

       446
       446
       +
                           #[serde(flatten)]

     

       447
       447
       +
                           #[serde(borrow)]

     

       448
       448
       +
                           #[builder(default)]

     

       449
       449
       +
                           pub extra_data: ::std::collections::BTreeMap<

     

       450
       450
       +
                               ::jacquard_common::smol_str::SmolStr,

     

       451
       451
       +
                               ::jacquard_common::types::value::Data<'a>

     

       452
       452
       +
                           >,

     

       453
       453
       +
                       }

     

       454
       454
       +
                   }

     

       455
       455
       +
               };

     

       456
       456
       +
       

     

       457
       457
       +
               // Generate union types if schema is an Object

     

       458
       458
       +
               let mut unions = Vec::new();

     

       459
       459
       +
               if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema {

     

       460
       460
       +
                   for (field_name, field_type) in &obj.properties {

     

       461
       461
       +
                       match field_type {

     

       462
       462
       +
                           LexObjectProperty::Union(union) => {

     

       463
       463
       +
                               // Skip empty, single-variant unions unless they're self-referential

     

       464
       464
       +
                               if !union.refs.is_empty() && (union.refs.len() > 1 || self.is_self_referential_union(nsid, type_base, union)) {

     

       465
       465
       +
                                   let union_name = self.generate_field_type_name(nsid, type_base, field_name, "");

     

       466
       466
       +
                                   let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       467
       467
       +
                                   let union_def =

     

       468
       468
       +
                                       self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       469
       469
       +
                                   unions.push(union_def);

     

       470
       470
       +
                               }

     

       471
       471
       +
                           }

     

       472
       472
       +
                           LexObjectProperty::Array(array) => {

     

       473
       473
       +
                               if let LexArrayItem::Union(union) = &array.items {

     

       474
       474
       +
                                   // Skip single-variant array unions

     

       475
       475
       +
                                   if union.refs.len() > 1 {

     

       476
       476
       +
                                       let union_name = self.generate_field_type_name(nsid, type_base, field_name, "Item");

     

       477
       477
       +
                                       let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       478
       478
       +
                                       let union_def = self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       479
       479
       +
                                       unions.push(union_def);

     

       480
       480
       +
                                   }

     

       481
       481
       +
                               }

     

       482
       482
       +
                           }

     

       483
       483
       +
                           _ => {}

     

       484
       484
       +
                       }

     

       485
       485
       +
                   }

     

       486
       486
       +
               }

     

       487
       487
       +
       

     

       488
       488
       +
               Ok(quote! {

     

       489
       489
       +
                   #struct_def

     

       490
       490
       +
                   #(#unions)*

     

       491
       491
       +
               })

     

       492
       492
       +
           }

     

       493
       493
       +
       

     

       494
       494
       +
           /// Generate output struct from XRPC body

     

       495
       495
       +
           pub(super) fn generate_output_struct(

     

       496
       496
       +
               &self,

     

       497
       497
       +
               nsid: &str,

     

       498
       498
       +
               type_base: &str,

     

       499
       499
       +
               body: &LexXrpcBody<'static>,

     

       500
       500
       +
           ) -> Result<TokenStream> {

     

       501
       501
       +
               let struct_name = format!("{}Output", type_base);

     

       502
       502
       +
               let ident = syn::Ident::new(&struct_name, proc_macro2::Span::call_site());

     

       503
       503
       +
       

     

       504
       504
       +
               let fields = if let Some(schema) = &body.schema {

     

       505
       505
       +
                   self.generate_body_fields("", &struct_name, schema, false)?

     

       506
       506
       +
               } else {

     

       507
       507
       +
                   quote! {}

     

       508
       508
       +
               };

     

       509
       509
       +
       

     

       510
       510
       +
               let doc = self.generate_doc_comment(body.description.as_ref());

     

       511
       511
       +
       

     

       512
       512
       +
               // Output structs always get a lifetime since they have the #[lexicon] attribute

     

       513
       513
       +
               // which adds extra_data: BTreeMap<..., Data<'a>>

     

       514
       514
       +
               let struct_def = quote! {

     

       515
       515
       +
                   #doc

     

       516
       516
       +
                   #[jacquard_derive::lexicon]

     

       517
       517
       +
                   #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic)]

     

       518
       518
       +
                   #[serde(rename_all = "camelCase")]

     

       519
       519
       +
                   pub struct #ident<'a> {

     

       520
       520
       +
                       #fields

     

       521
       521
       +
                   }

     

       522
       522
       +
               };

     

       523
       523
       +
       

     

       524
       524
       +
               // Generate union types if schema is an Object

     

       525
       525
       +
               let mut unions = Vec::new();

     

       526
       526
       +
               if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema {

     

       527
       527
       +
                   for (field_name, field_type) in &obj.properties {

     

       528
       528
       +
                       match field_type {

     

       529
       529
       +
                           LexObjectProperty::Union(union) => {

     

       530
       530
       +
                               // Skip single-variant unions unless they're self-referential

     

       531
       531
       +
                               if union.refs.len() > 1 || self.is_self_referential_union(nsid, &struct_name, union) {

     

       532
       532
       +
                                   let union_name = self.generate_field_type_name(nsid, &struct_name, field_name, "");

     

       533
       533
       +
                                   let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       534
       534
       +
                                   let union_def =

     

       535
       535
       +
                                       self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       536
       536
       +
                                   unions.push(union_def);

     

       537
       537
       +
                               }

     

       538
       538
       +
                           }

     

       539
       539
       +
                           LexObjectProperty::Array(array) => {

     

       540
       540
       +
                               if let LexArrayItem::Union(union) = &array.items {

     

       541
       541
       +
                                   // Skip single-variant array unions

     

       542
       542
       +
                                   if union.refs.len() > 1 {

     

       543
       543
       +
                                       let union_name = self.generate_field_type_name(nsid, &struct_name, field_name, "Item");

     

       544
       544
       +
                                       let refs: Vec<_> = union.refs.iter().cloned().collect();

     

       545
       545
       +
                                       let union_def = self.generate_union(nsid, &union_name, &refs, None, union.closed)?;

     

       546
       546
       +
                                       unions.push(union_def);

     

       547
       547
       +
                                   }

     

       548
       548
       +
                               }

     

       549
       549
       +
                           }

     

       550
       550
       +
                           _ => {}

     

       551
       551
       +
                       }

     

       552
       552
       +
                   }

     

       553
       553
       +
               }

     

       554
       554
       +
       

     

       555
       555
       +
               Ok(quote! {

     

       556
       556
       +
                   #struct_def

     

       557
       557
       +
                   #(#unions)*

     

       558
       558
       +
               })

     

       559
       559
       +
           }

     

       560
       560
       +
       

     

       561
       561
       +
           /// Generate fields from XRPC body schema

     

       562
       562
       +
           pub(super) fn generate_body_fields(

     

       563
       563
       +
               &self,

     

       564
       564
       +
               nsid: &str,

     

       565
       565
       +
               parent_type_name: &str,

     

       566
       566
       +
               schema: &LexXrpcBodySchema<'static>,

     

       567
       567
       +
               is_builder: bool,

     

       568
       568
       +
           ) -> Result<TokenStream> {

     

       569
       569
       +
               use crate::lexicon::LexXrpcBodySchema;

     

       570
       570
       +
       

     

       571
       571
       +
               match schema {

     

       572
       572
       +
                   LexXrpcBodySchema::Object(obj) => {

     

       573
       573
       +
                       self.generate_object_fields(nsid, parent_type_name, obj, is_builder)

     

       574
       574
       +
                   }

     

       575
       575
       +
                   LexXrpcBodySchema::Ref(ref_type) => {

     

       576
       576
       +
                       let rust_type = self.ref_to_rust_type(&ref_type.r#ref)?;

     

       577
       577
       +
                       Ok(quote! {

     

       578
       578
       +
                           #[serde(flatten)]

     

       579
       579
       +
                           #[serde(borrow)]

     

       580
       580
       +
                           pub value: #rust_type,

     

       581
       581
       +
                       })

     

       582
       582
       +
                   }

     

       583
       583
       +
                   LexXrpcBodySchema::Union(_union) => {

     

       584
       584
       +
                       let rust_type = quote! { jacquard_common::types::value::Data<'a> };

     

       585
       585
       +
                       Ok(quote! {

     

       586
       586
       +
                           #[serde(flatten)]

     

       587
       587
       +
                           #[serde(borrow)]

     

       588
       588
       +
                           pub value: #rust_type,

     

       589
       589
       +
                       })

     

       590
       590
       +
                   }

     

       591
       591
       +
               }

     

       592
       592
       +
           }

     

       593
       593
       +
       

     

       594
       594
       +
           /// Generate a field for XRPC parameters

     

       595
       595
       +
           pub(super) fn generate_param_field(

     

       596
       596
       +
               &self,

     

       597
       597
       +
               _nsid: &str,

     

       598
       598
       +
               field_name: &str,

     

       599
       599
       +
               field_type: &crate::lexicon::LexXrpcParametersProperty<'static>,

     

       600
       600
       +
               is_required: bool,

     

       601
       601
       +
           ) -> Result<TokenStream> {

     

       602
       602
       +
               use crate::lexicon::LexXrpcParametersProperty;

     

       603
       603
       +
       

     

       604
       604
       +
               let field_ident = make_ident(&field_name.to_snake_case());

     

       605
       605
       +
       

     

       606
       606
       +
               let (rust_type, needs_lifetime, is_cowstr) = match field_type {

     

       607
       607
       +
                   LexXrpcParametersProperty::Boolean(_) => (quote! { bool }, false, false),

     

       608
       608
       +
                   LexXrpcParametersProperty::Integer(_) => (quote! { i64 }, false, false),

     

       609
       609
       +
                   LexXrpcParametersProperty::String(s) => {

     

       610
       610
       +
                       let is_cowstr = s.format.is_none(); // CowStr for plain strings

     

       611
       611
       +
                       (

     

       612
       612
       +
                           self.string_to_rust_type(s),

     

       613
       613
       +
                           self.string_needs_lifetime(s),

     

       614
       614
       +
                           is_cowstr,

     

       615
       615
       +
                       )

     

       616
       616
       +
                   }

     

       617
       617
       +
                   LexXrpcParametersProperty::Unknown(_) => (

     

       618
       618
       +
                       quote! { jacquard_common::types::value::Data<'a> },

     

       619
       619
       +
                       true,

     

       620
       620
       +
                       false,

     

       621
       621
       +
                   ),

     

       622
       622
       +
                   LexXrpcParametersProperty::Array(arr) => {

     

       623
       623
       +
                       let needs_lifetime = match &arr.items {

     

       624
       624
       +
                           crate::lexicon::LexPrimitiveArrayItem::Boolean(_)

     

       625
       625
       +
                           | crate::lexicon::LexPrimitiveArrayItem::Integer(_) => false,

     

       626
       626
       +
                           crate::lexicon::LexPrimitiveArrayItem::String(s) => {

     

       627
       627
       +
                               self.string_needs_lifetime(s)

     

       628
       628
       +
                           }

     

       629
       629
       +
                           crate::lexicon::LexPrimitiveArrayItem::Unknown(_) => true,

     

       630
       630
       +
                       };

     

       631
       631
       +
                       let item_type = match &arr.items {

     

       632
       632
       +
                           crate::lexicon::LexPrimitiveArrayItem::Boolean(_) => quote! { bool },

     

       633
       633
       +
                           crate::lexicon::LexPrimitiveArrayItem::Integer(_) => quote! { i64 },

     

       634
       634
       +
                           crate::lexicon::LexPrimitiveArrayItem::String(s) => self.string_to_rust_type(s),

     

       635
       635
       +
                           crate::lexicon::LexPrimitiveArrayItem::Unknown(_) => {

     

       636
       636
       +
                               quote! { jacquard_common::types::value::Data<'a> }

     

       637
       637
       +
                           }

     

       638
       638
       +
                       };

     

       639
       639
       +
                       (quote! { Vec<#item_type> }, needs_lifetime, false)

     

       640
       640
       +
                   }

     

       641
       641
       +
               };

     

       642
       642
       +
       

     

       643
       643
       +
               let rust_type = if is_required {

     

       644
       644
       +
                   rust_type

     

       645
       645
       +
               } else {

     

       646
       646
       +
                   quote! { std::option::Option<#rust_type> }

     

       647
       647
       +
               };

     

       648
       648
       +
       

     

       649
       649
       +
               let mut attrs = Vec::new();

     

       650
       650
       +
       

     

       651
       651
       +
               if !is_required {

     

       652
       652
       +
                   attrs.push(quote! { #[serde(skip_serializing_if = "std::option::Option::is_none")] });

     

       653
       653
       +
               }

     

       654
       654
       +
       

     

       655
       655
       +
               // Add serde(borrow) to all fields with lifetimes

     

       656
       656
       +
               if needs_lifetime {

     

       657
       657
       +
                   attrs.push(quote! { #[serde(borrow)] });

     

       658
       658
       +
               }

     

       659
       659
       +
       

     

       660
       660
       +
               // Add builder(into) for CowStr fields to allow String, &str, etc.

     

       661
       661
       +
               if is_cowstr {

     

       662
       662
       +
                   attrs.push(quote! { #[builder(into)] });

     

       663
       663
       +
               }

     

       664
       664
       +
       

     

       665
       665
       +
               Ok(quote! {

     

       666
       666
       +
                   #(#attrs)*

     

       667
       667
       +
                   pub #field_ident: #rust_type,

     

       668
       668
       +
               })

     

       669
       669
       +
           }

     

       670
       670
       +
       

     

       671
       671
       +
           /// Generate param field with serde default if present

     

       672
       672
       +
           /// Returns (field_tokens, optional_default_function)

     

       673
       673
       +
           pub(super) fn generate_param_field_with_default(

     

       674
       674
       +
               &self,

     

       675
       675
       +
               nsid: &str,

     

       676
       676
       +
               field_name: &str,

     

       677
       677
       +
               field_type: &crate::lexicon::LexXrpcParametersProperty<'static>,

     

       678
       678
       +
               is_required: bool,

     

       679
       679
       +
           ) -> Result<(TokenStream, Option<TokenStream>)> {

     

       680
       680
       +
               use crate::lexicon::LexXrpcParametersProperty;

     

       681
       681
       +
               use heck::ToSnakeCase;

     

       682
       682
       +
       

     

       683
       683
       +
               // Get base field

     

       684
       684
       +
               let base_field = self.generate_param_field(nsid, field_name, field_type, is_required)?;

     

       685
       685
       +
       

     

       686
       686
       +
               // Generate default function and attribute for required fields with defaults

     

       687
       687
       +
               // For optional fields, just add doc comments

     

       688
       688
       +
               let (doc_comment, serde_attr, default_fn) = if is_required {

     

       689
       689
       +
                   match field_type {

     

       690
       690
       +
                       LexXrpcParametersProperty::Boolean(b) if b.default.is_some() => {

     

       691
       691
       +
                           let v = b.default.unwrap();

     

       692
       692
       +
                           let fn_name = format!("_default_{}", field_name.to_snake_case());

     

       693
       693
       +
                           let fn_ident = syn::Ident::new(&fn_name, proc_macro2::Span::call_site());

     

       694
       694
       +
                           (

     

       695
       695
       +
                               Some(format!("Defaults to `{}`", v)),

     

       696
       696
       +
                               Some(quote! { #[serde(default = #fn_name)] }),

     

       697
       697
       +
                               Some(quote! {

     

       698
       698
       +
                                   fn #fn_ident() -> bool { #v }

     

       699
       699
       +
                               }),

     

       700
       700
       +
                           )

     

       701
       701
       +
                       }

     

       702
       702
       +
                       LexXrpcParametersProperty::Integer(i) if i.default.is_some() => {

     

       703
       703
       +
                           let v = i.default.unwrap();

     

       704
       704
       +
                           let fn_name = format!("_default_{}", field_name.to_snake_case());

     

       705
       705
       +
                           let fn_ident = syn::Ident::new(&fn_name, proc_macro2::Span::call_site());

     

       706
       706
       +
                           (

     

       707
       707
       +
                               Some(format!("Defaults to `{}`", v)),

     

       708
       708
       +
                               Some(quote! { #[serde(default = #fn_name)] }),

     

       709
       709
       +
                               Some(quote! {

     

       710
       710
       +
                                   fn #fn_ident() -> i64 { #v }

     

       711
       711
       +
                               }),

     

       712
       712
       +
                           )

     

       713
       713
       +
                       }

     

       714
       714
       +
                       LexXrpcParametersProperty::String(s) if s.default.is_some() => {

     

       715
       715
       +
                           let v = s.default.as_ref().unwrap().as_ref();

     

       716
       716
       +
                           let fn_name = format!("_default_{}", field_name.to_snake_case());

     

       717
       717
       +
                           let fn_ident = syn::Ident::new(&fn_name, proc_macro2::Span::call_site());

     

       718
       718
       +
                           (

     

       719
       719
       +
                               Some(format!("Defaults to `\"{}\"`", v)),

     

       720
       720
       +
                               Some(quote! { #[serde(default = #fn_name)] }),

     

       721
       721
       +
                               Some(quote! {

     

       722
       722
       +
                                   fn #fn_ident() -> jacquard_common::CowStr<'static> {

     

       723
       723
       +
                                       jacquard_common::CowStr::from(#v)

     

       724
       724
       +
                                   }

     

       725
       725
       +
                               }),

     

       726
       726
       +
                           )

     

       727
       727
       +
                       }

     

       728
       728
       +
                       _ => (None, None, None),

     

       729
       729
       +
                   }

     

       730
       730
       +
               } else {

     

       731
       731
       +
                   // Optional fields - just doc comments, no serde defaults

     

       732
       732
       +
                   let doc = match field_type {

     

       733
       733
       +
                       LexXrpcParametersProperty::Integer(i) => {

     

       734
       734
       +
                           let mut parts = Vec::new();

     

       735
       735
       +
                           if let Some(def) = i.default {

     

       736
       736
       +
                               parts.push(format!("default: {}", def));

     

       737
       737
       +
                           }

     

       738
       738
       +
                           if let Some(min) = i.minimum {

     

       739
       739
       +
                               parts.push(format!("min: {}", min));

     

       740
       740
       +
                           }

     

       741
       741
       +
                           if let Some(max) = i.maximum {

     

       742
       742
       +
                               parts.push(format!("max: {}", max));

     

       743
       743
       +
                           }

     

       744
       744
       +
                           if !parts.is_empty() {

     

       745
       745
       +
                               Some(format!("({})", parts.join(", ")))

     

       746
       746
       +
                           } else {

     

       747
       747
       +
                               None

     

       748
       748
       +
                           }

     

       749
       749
       +
                       }

     

       750
       750
       +
                       LexXrpcParametersProperty::String(s) => {

     

       751
       751
       +
                           let mut parts = Vec::new();

     

       752
       752
       +
                           if let Some(def) = s.default.as_ref() {

     

       753
       753
       +
                               parts.push(format!("default: \"{}\"", def.as_ref()));

     

       754
       754
       +
                           }

     

       755
       755
       +
                           if let Some(min) = s.min_length {

     

       756
       756
       +
                               parts.push(format!("min length: {}", min));

     

       757
       757
       +
                           }

     

       758
       758
       +
                           if let Some(max) = s.max_length {

     

       759
       759
       +
                               parts.push(format!("max length: {}", max));

     

       760
       760
       +
                           }

     

       761
       761
       +
                           if !parts.is_empty() {

     

       762
       762
       +
                               Some(format!("({})", parts.join(", ")))

     

       763
       763
       +
                           } else {

     

       764
       764
       +
                               None

     

       765
       765
       +
                           }

     

       766
       766
       +
                       }

     

       767
       767
       +
                       LexXrpcParametersProperty::Boolean(b) => {

     

       768
       768
       +
                           b.default.map(|v| format!("(default: {})", v))

     

       769
       769
       +
                       }

     

       770
       770
       +
                       _ => None,

     

       771
       771
       +
                   };

     

       772
       772
       +
                   (doc, None, None)

     

       773
       773
       +
               };

     

       774
       774
       +
       

     

       775
       775
       +
               let doc = doc_comment.as_ref().map(|d| quote! { #[doc = #d] });

     

       776
       776
       +
               let field_with_attrs = match (doc, serde_attr) {

     

       777
       777
       +
                   (Some(doc), Some(attr)) => quote! {

     

       778
       778
       +
                       #doc

     

       779
       779
       +
                       #attr

     

       780
       780
       +
                       #base_field

     

       781
       781
       +
                   },

     

       782
       782
       +
                   (Some(doc), None) => quote! {

     

       783
       783
       +
                       #doc

     

       784
       784
       +
                       #base_field

     

       785
       785
       +
                   },

     

       786
       786
       +
                   (None, Some(attr)) => quote! {

     

       787
       787
       +
                       #attr

     

       788
       788
       +
                       #base_field

     

       789
       789
       +
                   },

     

       790
       790
       +
                   (None, None) => base_field,

     

       791
       791
       +
               };

     

       792
       792
       +
       

     

       793
       793
       +
               Ok((field_with_attrs, default_fn))

     

       794
       794
       +
           }

     

       795
       795
       +
       

     

       796
       796
       +
           /// Generate error enum from XRPC errors

     

       797
       797
       +
           pub(super) fn generate_error_enum(

     

       798
       798
       +
               &self,

     

       799
       799
       +
               type_base: &str,

     

       800
       800
       +
               errors: &[LexXrpcError<'static>],

     

       801
       801
       +
           ) -> Result<TokenStream> {

     

       802
       802
       +
               let enum_name = format!("{}Error", type_base);

     

       803
       803
       +
               let ident = syn::Ident::new(&enum_name, proc_macro2::Span::call_site());

     

       804
       804
       +
       

     

       805
       805
       +
               let mut variants = Vec::new();

     

       806
       806
       +
               let mut display_arms = Vec::new();

     

       807
       807
       +
       

     

       808
       808
       +
               for error in errors {

     

       809
       809
       +
                   let variant_name = error.name.to_pascal_case();

     

       810
       810
       +
                   let variant_ident = syn::Ident::new(&variant_name, proc_macro2::Span::call_site());

     

       811
       811
       +
       

     

       812
       812
       +
                   let error_name = error.name.as_ref();

     

       813
       813
       +
                   let doc = self.generate_doc_comment(error.description.as_ref());

     

       814
       814
       +
       

     

       815
       815
       +
                   variants.push(quote! {

     

       816
       816
       +
                       #doc

     

       817
       817
       +
                       #[serde(rename = #error_name)]

     

       818
       818
       +
                       #variant_ident(std::option::Option<String>)

     

       819
       819
       +
                   });

     

       820
       820
       +
       

     

       821
       821
       +
                   display_arms.push(quote! {

     

       822
       822
       +
                       Self::#variant_ident(msg) => {

     

       823
       823
       +
                           write!(f, #error_name)?;

     

       824
       824
       +
                           if let Some(msg) = msg {

     

       825
       825
       +
                               write!(f, ": {}", msg)?;

     

       826
       826
       +
                           }

     

       827
       827
       +
                           Ok(())

     

       828
       828
       +
                       }

     

       829
       829
       +
                   });

     

       830
       830
       +
               }

     

       831
       831
       +
       

     

       832
       832
       +
               // IntoStatic impl is generated by the derive macro now

     

       833
       833
       +
       

     

       834
       834
       +
               Ok(quote! {

     

       835
       835
       +
                   #[jacquard_derive::open_union]

     

       836
       836
       +
                   #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, thiserror::Error, miette::Diagnostic, jacquard_derive::IntoStatic)]

     

       837
       837
       +
                   #[serde(tag = "error", content = "message")]

     

       838
       838
       +
                   #[serde(bound(deserialize = "'de: 'a"))]

     

       839
       839
       +
                   pub enum #ident<'a> {

     

       840
       840
       +
                       #(#variants,)*

     

       841
       841
       +
                   }

     

       842
       842
       +
       

     

       843
       843
       +
                   impl std::fmt::Display for #ident<'_> {

     

       844
       844
       +
                       fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

     

       845
       845
       +
                           match self {

     

       846
       846
       +
                               #(#display_arms)*

     

       847
       847
       +
                               Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),

     

       848
       848
       +
                           }

     

       849
       849
       +
                       }

     

       850
       850
       +
                   }

     

       851
       851
       +
               })

     

       852
       852
       +
           }

     

       853
       853
       +
       

     

       854
       854
       +
           /// Generate XrpcRequest trait impl for a query or procedure

     

       855
       855
       +
           pub(super) fn generate_xrpc_request_impl(

     

       856
       856
       +
               &self,

     

       857
       857
       +
               nsid: &str,

     

       858
       858
       +
               type_base: &str,

     

       859
       859
       +
               method: TokenStream,

     

       860
       860
       +
               output_encoding: &str,

     

       861
       861
       +
               has_params: bool,

     

       862
       862
       +
               params_has_lifetime: bool,

     

       863
       863
       +
               has_output: bool,

     

       864
       864
       +
               has_errors: bool,

     

       865
       865
       +
               is_binary_input: bool,

     

       866
       866
       +
           ) -> Result<TokenStream> {

     

       867
       867
       +
               let output_type = if has_output {

     

       868
       868
       +
                   let output_ident = syn::Ident::new(

     

       869
       869
       +
                       &format!("{}Output", type_base),

     

       870
       870
       +
                       proc_macro2::Span::call_site(),

     

       871
       871
       +
                   );

     

       872
       872
       +
                   quote! { #output_ident<'de> }

     

       873
       873
       +
               } else {

     

       874
       874
       +
                   quote! { () }

     

       875
       875
       +
               };

     

       876
       876
       +
       

     

       877
       877
       +
               let error_type = if has_errors {

     

       878
       878
       +
                   let error_ident = syn::Ident::new(

     

       879
       879
       +
                       &format!("{}Error", type_base),

     

       880
       880
       +
                       proc_macro2::Span::call_site(),

     

       881
       881
       +
                   );

     

       882
       882
       +
                   quote! { #error_ident<'de> }

     

       883
       883
       +
               } else {

     

       884
       884
       +
                   quote! { jacquard_common::xrpc::GenericError<'de> }

     

       885
       885
       +
               };

     

       886
       886
       +
       

     

       887
       887
       +
               // Generate the response type that implements XrpcResp

     

       888
       888
       +
               let response_ident = syn::Ident::new(

     

       889
       889
       +
                   &format!("{}Response", type_base),

     

       890
       890
       +
                   proc_macro2::Span::call_site(),

     

       891
       891
       +
               );

     

       892
       892
       +
       

     

       893
       893
       +
               // Generate the endpoint type that implements XrpcEndpoint

     

       894
       894
       +
               let endpoint_ident = syn::Ident::new(

     

       895
       895
       +
                   &format!("{}Request", type_base),

     

       896
       896
       +
                   proc_macro2::Span::call_site(),

     

       897
       897
       +
               );

     

       898
       898
       +
       

     

       899
       899
       +
               let response_type = quote! {

     

       900
       900
       +
                   #[doc = "Response type for "]

     

       901
       901
       +
                   #[doc = #nsid]

     

       902
       902
       +
                   pub struct #response_ident;

     

       903
       903
       +
       

     

       904
       904
       +
                   impl jacquard_common::xrpc::XrpcResp for #response_ident {

     

       905
       905
       +
                       const NSID: &'static str = #nsid;

     

       906
       906
       +
                       const ENCODING: &'static str = #output_encoding;

     

       907
       907
       +
                       type Output<'de> = #output_type;

     

       908
       908
       +
                       type Err<'de> = #error_type;

     

       909
       909
       +
                   }

     

       910
       910
       +
               };

     

       911
       911
       +
       

     

       912
       912
       +
               // Generate encode_body() method for binary inputs

     

       913
       913
       +
               let encode_body_method = if is_binary_input {

     

       914
       914
       +
                   quote! {

     

       915
       915
       +
                       fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::xrpc::EncodeError> {

     

       916
       916
       +
                           Ok(self.body.to_vec())

     

       917
       917
       +
                       }

     

       918
       918
       +
                   }

     

       919
       919
       +
               } else {

     

       920
       920
       +
                   quote! {}

     

       921
       921
       +
               };

     

       922
       922
       +
       

     

       923
       923
       +
               // Generate decode_body() method for binary inputs

     

       924
       924
       +
               let decode_body_method = if is_binary_input {

     

       925
       925
       +
                   quote! {

     

       926
       926
       +
                       fn decode_body(

     

       927
       927
       +
                           body: &'de [u8],

     

       928
       928
       +
                       ) -> Result<Box<Self>, jacquard_common::error::DecodeError> {

     

       929
       929
       +
                           Ok(Box::new(Self {

     

       930
       930
       +
                               body: bytes::Bytes::copy_from_slice(body),

     

       931
       931
       +
                           }))

     

       932
       932
       +
                       }

     

       933
       933
       +
                   }

     

       934
       934
       +
               } else {

     

       935
       935
       +
                   quote! {}

     

       936
       936
       +
               };

     

       937
       937
       +
       

     

       938
       938
       +
               let endpoint_path = format!("/xrpc/{}", nsid);

     

       939
       939
       +
       

     

       940
       940
       +
               if has_params {

     

       941
       941
       +
                   // Implement on the params/input struct itself

     

       942
       942
       +
                   let request_ident = syn::Ident::new(type_base, proc_macro2::Span::call_site());

     

       943
       943
       +
                   let impl_target = if params_has_lifetime {

     

       944
       944
       +
                       quote! { #request_ident<'de> }

     

       945
       945
       +
                   } else {

     

       946
       946
       +
                       quote! { #request_ident }

     

       947
       947
       +
                   };

     

       948
       948
       +
       

     

       949
       949
       +
                   Ok(quote! {

     

       950
       950
       +
                       #response_type

     

       951
       951
       +
       

     

       952
       952
       +
                       impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for #impl_target {

     

       953
       953
       +
                           const NSID: &'static str = #nsid;

     

       954
       954
       +
                           const METHOD: jacquard_common::xrpc::XrpcMethod = #method;

     

       955
       955
       +
       

     

       956
       956
       +
                           type Response = #response_ident;

     

       957
       957
       +
       

     

       958
       958
       +
                           #encode_body_method

     

       959
       959
       +
                           #decode_body_method

     

       960
       960
       +
                       }

     

       961
       961
       +
       

     

       962
       962
       +
                       #[doc = "Endpoint type for "]

     

       963
       963
       +
                       #[doc = #nsid]

     

       964
       964
       +
                       pub struct #endpoint_ident;

     

       965
       965
       +
       

     

       966
       966
       +
                       impl jacquard_common::xrpc::XrpcEndpoint for #endpoint_ident {

     

       967
       967
       +
                           const PATH: &'static str = #endpoint_path;

     

       968
       968
       +
                           const METHOD: jacquard_common::xrpc::XrpcMethod = #method;

     

       969
       969
       +
       

     

       970
       970
       +
                           type Request<'de> = #impl_target;

     

       971
       971
       +
                           type Response = #response_ident;

     

       972
       972
       +
                       }

     

       973
       973
       +
                   })

     

       974
       974
       +
               } else {

     

       975
       975
       +
                   // No params - generate a marker struct

     

       976
       976
       +
                   let request_ident = syn::Ident::new(type_base, proc_macro2::Span::call_site());

     

       977
       977
       +
       

     

       978
       978
       +
                   Ok(quote! {

     

       979
       979
       +
                       /// XRPC request marker type

     

       980
       980
       +
                       #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, jacquard_derive::IntoStatic)]

     

       981
       981
       +
                       pub struct #request_ident;

     

       982
       982
       +
       

     

       983
       983
       +
                       #response_type

     

       984
       984
       +
       

     

       985
       985
       +
                       impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for #request_ident {

     

       986
       986
       +
                           const NSID: &'static str = #nsid;

     

       987
       987
       +
                           const METHOD: jacquard_common::xrpc::XrpcMethod = #method;

     

       988
       988
       +
       

     

       989
       989
       +
                           type Response = #response_ident;

     

       990
       990
       +
                       }

     

       991
       991
       +
       

     

       992
       992
       +
                       #[doc = "Endpoint type for "]

     

       993
       993
       +
                       #[doc = #nsid]

     

       994
       994
       +
                       pub struct #endpoint_ident;

     

       995
       995
       +
       

     

       996
       996
       +
                       impl jacquard_common::xrpc::XrpcEndpoint for #endpoint_ident {

     

       997
       997
       +
                           const PATH: &'static str = #endpoint_path;

     

       998
       998
       +
                           const METHOD: jacquard_common::xrpc::XrpcMethod = #method;

     

       999
       999
       +
       

     

       1000
       1000
       +
                           type Request<'de> = #request_ident;

     

       1001
       1001
       +
                           type Response = #response_ident;

     

       1002
       1002
       +
                       }

     

       1003
       1003
       +
                   })

     

       1004
       1004
       +
               }

     

       1005
       1005
       +
           }

     

       1006
       1006
       +
       }