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

//! Per-scalar-field match arms emitted into the generated
//! `<model>_filter_expr` / `<model>_order_by` switch tables. Each arm
//! pairs `(field_name, operator)` with a `FieldRef<...>` call on the
//! per-field accessor in the field module.

use cratestack_core::{Field, TypeArity};
use quote::quote;

use crate::shared::{
    ident, query_scalar_list_parser_tokens, query_scalar_parser_tokens, supports_comparison,
};

pub(super) fn generate_query_filter_arm(
    field_module_ident: &syn::Ident,
    field: &Field,
) -> Option<proc_macro2::TokenStream> {
    let field_name = &field.name;
    let field_fn = ident(&field.name);
    let scalar_parser = query_scalar_parser_tokens(&field.ty, quote! { value }, field_name)?;
    let mut arms = Vec::new();

    if field.ty.arity == TypeArity::Required {
        let list_parser = query_scalar_list_parser_tokens(&field.ty, field_name)?;
        arms.push(quote! {
            (#field_name, "eq") => {
                let parsed = (#scalar_parser)?;
                Ok(::cratestack::FilterExpr::from(super::#field_module_ident::#field_fn().eq(parsed)))
            }
        });
        arms.push(quote! {
            (#field_name, "ne") => {
                let parsed = (#scalar_parser)?;
                Ok(::cratestack::FilterExpr::from(super::#field_module_ident::#field_fn().ne(parsed)))
            }
        });
        arms.push(quote! {
            (#field_name, "in") => {
                let parsed = #list_parser;
                Ok(::cratestack::FilterExpr::from(super::#field_module_ident::#field_fn().in_(parsed)))
            }
        });
        if supports_comparison(field) {
            arms.push(quote! {
                (#field_name, "lt") => {
                    let parsed = (#scalar_parser)?;
                    Ok(::cratestack::FilterExpr::from(super::#field_module_ident::#field_fn().lt(parsed)))
                }
            });
            arms.push(quote! {
                (#field_name, "lte") => {
                    let parsed = (#scalar_parser)?;
                    Ok(::cratestack::FilterExpr::from(super::#field_module_ident::#field_fn().lte(parsed)))
                }
            });
            arms.push(quote! {
                (#field_name, "gt") => {
                    let parsed = (#scalar_parser)?;
                    Ok(::cratestack::FilterExpr::from(super::#field_module_ident::#field_fn().gt(parsed)))
                }
            });
            arms.push(quote! {
                (#field_name, "gte") => {
                    let parsed = (#scalar_parser)?;
                    Ok(::cratestack::FilterExpr::from(super::#field_module_ident::#field_fn().gte(parsed)))
                }
            });
        }
    }

    if matches!(field.ty.name.as_str(), "String" | "Cuid")
        && matches!(field.ty.arity, TypeArity::Required | TypeArity::Optional)
    {
        arms.push(quote! {
            (#field_name, "contains") => {
                Ok(::cratestack::FilterExpr::from(super::#field_module_ident::#field_fn().contains(value.to_owned())))
            }
        });
        arms.push(quote! {
            (#field_name, "startsWith") => {
                Ok(::cratestack::FilterExpr::from(super::#field_module_ident::#field_fn().starts_with(value.to_owned())))
            }
        });
    }

    if field.ty.arity == TypeArity::Optional {
        arms.push(quote! {
            (#field_name, "isNull") => {
                let parsed = value.parse::<bool>().map_err(|error| {
                    CoolError::BadRequest(format!("invalid value '{}' for {}__isNull: {error}", value, #field_name))
                })?;
                Ok(if parsed {
                    ::cratestack::FilterExpr::from(super::#field_module_ident::#field_fn().is_null())
                } else {
                    ::cratestack::FilterExpr::from(super::#field_module_ident::#field_fn().is_not_null())
                })
            }
        });
    }

    if arms.is_empty() {
        None
    } else {
        Some(quote! { #(#arms)* })
    }
}

pub(super) fn generate_order_by_arm(
    field_module_ident: &syn::Ident,
    field: &Field,
) -> proc_macro2::TokenStream {
    let field_name = &field.name;
    let field_fn = ident(&field.name);

    quote! {
        #field_name => {
            if descending {
                request.order_by(super::#field_module_ident::#field_fn().desc())
            } else {
                request.order_by(super::#field_module_ident::#field_fn().asc())
            }
        }
    }
}