cratestack-macros 0.4.4

Rust-native schema-first framework for typed HTTP APIs, generated clients, and backend services.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! `Selection` + `Projection` impl + `IncludeSelection`. Both
//! selection types share the same `fields`/`includes` shape plus the
//! generated per-field setters; `Selection` adds the
//! `Projection`-trait decode hooks while `IncludeSelection` is
//! query-only.

use quote::quote;

pub(super) fn build_selection_block(
    model_name: &str,
    selection_field_methods: &[proc_macro2::TokenStream],
    include_selection_field_methods: &[proc_macro2::TokenStream],
    include_methods: &[proc_macro2::TokenStream],
    include_query_steps: &[proc_macro2::TokenStream],
) -> proc_macro2::TokenStream {
    quote! {
        #[derive(Debug, Clone, Default)]
        pub struct Selection {
            fields: Option<::std::collections::BTreeSet<&'static str>>,
            includes: Includes,
        }

        impl Selection {
            pub fn all_fields(mut self) -> Self {
                self.fields = None;
                self
            }

            #(#selection_field_methods)*
            #(#include_methods)*

            pub fn to_query(&self) -> ::cratestack::SelectionQuery {
                let mut query = ::cratestack::SelectionQuery::default();
                if let Some(fields) = &self.fields {
                    query.fields = fields.iter().map(|field| (*field).to_owned()).collect();
                }
                #(#include_query_steps)*
                query
            }

            pub fn decode_one(
                &self,
                value: ::cratestack::serde_json::Value,
            ) -> Result<Projected, ::cratestack::CoolError> {
                Projected::from_value(value, self.clone())
            }

            pub fn decode_many(
                &self,
                value: ::cratestack::serde_json::Value,
            ) -> Result<Vec<Projected>, ::cratestack::CoolError> {
                match value {
                    ::cratestack::serde_json::Value::Array(values) => values
                        .into_iter()
                        .map(|value| self.decode_one(value))
                        .collect(),
                    other => Err(::cratestack::CoolError::Internal(format!(
                        "projected {} list payload must be an array, got {other:?}",
                        #model_name,
                    ))),
                }
            }

            pub fn decode_page(
                &self,
                value: ::cratestack::serde_json::Value,
            ) -> Result<::cratestack::Page<Projected>, ::cratestack::CoolError> {
                let page = ::cratestack::serde_json::from_value::<::cratestack::Page<::cratestack::serde_json::Value>>(value)
                    .map_err(|error| ::cratestack::CoolError::Codec(format!(
                        "failed to decode projected {} page payload: {error}",
                        #model_name,
                    )))?;
                let items = page
                    .items
                    .into_iter()
                    .map(|value| self.decode_one(value))
                    .collect::<Result<Vec<_>, _>>()?;
                Ok(::cratestack::Page::new(items, page.page_info).with_total_count(page.total_count))
            }
        }

        impl ::cratestack::ProjectionDecoder for Selection {
            type Output = Projected;

            fn selection_query(&self) -> ::cratestack::SelectionQuery {
                self.to_query()
            }

            fn decode_one(
                &self,
                value: ::cratestack::serde_json::Value,
            ) -> Result<Self::Output, ::cratestack::CoolError> {
                Selection::decode_one(self, value)
            }

            fn decode_many(
                &self,
                value: ::cratestack::serde_json::Value,
            ) -> Result<Vec<Self::Output>, ::cratestack::CoolError> {
                Selection::decode_many(self, value)
            }

            fn decode_page(
                &self,
                value: ::cratestack::serde_json::Value,
            ) -> Result<::cratestack::Page<Self::Output>, ::cratestack::CoolError> {
                Selection::decode_page(self, value)
            }
        }

        #[derive(Debug, Clone, Default)]
        pub struct IncludeSelection {
            fields: Option<::std::collections::BTreeSet<&'static str>>,
            includes: Includes,
        }

        impl IncludeSelection {
            pub fn all_fields(mut self) -> Self {
                self.fields = None;
                self
            }

            #(#include_selection_field_methods)*
            #(#include_methods)*

            pub fn to_query(&self) -> ::cratestack::SelectionQuery {
                let mut query = ::cratestack::SelectionQuery::default();
                if let Some(fields) = &self.fields {
                    query.fields = fields.iter().map(|field| (*field).to_owned()).collect();
                }
                #(#include_query_steps)*
                query
            }
        }
    }
}