eventstore-macros 0.0.1

Extra EventStoreDB gRPC client internal code generation features
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

use proc_macro::TokenStream;
use quote::quote;
use syn::{
    parse::{Parse, ParseStream},
    parse_macro_input, AttrStyle, Attribute, FieldsNamed, Ident, Token, Visibility,
};

struct Structure {
    attrs: Vec<Attribute>,
    visibility: Visibility,
    _struct_token: Token![struct],
    name: Ident,
    fields: FieldsNamed,
}

impl Parse for Structure {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        Ok(Structure {
            attrs: input.call(Attribute::parse_outer)?,
            visibility: input.parse()?,
            _struct_token: input.parse()?,
            name: input.parse()?,
            fields: input.parse()?,
        })
    }
}

fn attr_has_streaming_name(attr: &Attribute) -> bool {
    attr.style == AttrStyle::Outer && attr.path.is_ident("streaming")
}

#[proc_macro_attribute]
pub fn streaming(_attr: TokenStream, item: TokenStream) -> TokenStream {
    item
}

#[proc_macro]
pub fn options(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as Structure);

    let fields = input.fields.named.iter().map(|field| {
        let attrs = if field.attrs.is_empty() {
            quote! {}
        } else {
            let attrs = field.attrs.iter().map(|attr| quote! { #attr });
            quote! {
                #(#attrs)*
            }
        };

        let vis = &field.vis;
        let name = &field.ident;
        let ty = &field.ty;

        quote! {
            #attrs
            #vis #name: #ty,
        }
    });

    let is_streaming = input.attrs.iter().any(attr_has_streaming_name);

    let kind = if is_streaming {
        quote! {
            crate::options::OperationKind::Streaming
        }
    } else {
        quote! {
            crate::options::OperationKind::Regular
        }
    };

    let attrs = input.attrs.iter().map(|attr| quote! { #attr });
    let vis = &input.visibility;
    let name = input.name;

    TokenStream::from(quote! {
        #(#attrs)*
        #vis struct #name {
            #(#fields)*
            pub(crate) common_operation_options: crate::options::CommonOperationOptions,
        }

        impl crate::options::Options for #name {
            fn common_operation_options(&self) -> &crate::options::CommonOperationOptions {
                &self.common_operation_options
            }

            fn kind(&self) -> crate::options::OperationKind {
                #kind
            }
        }

        impl #name {
            /// Performs the command with the given credentials.
            pub fn authenticated(mut self, credentials: crate::types::Credentials) -> Self {
                self.common_operation_options.credentials = Some(credentials);
                self
            }

            pub fn requires_leader(mut self, requires_leader: bool) -> Self {
                self.common_operation_options.requires_leader = requires_leader;
                self
            }

            pub fn deadline(mut self, deadline: std::time::Duration) -> Self {
                self.common_operation_options.deadline = Some(deadline);
                self
            }
        }
    })
}