zod-derive 0.1.0

Rust integraions with the `zod` typescript library.
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

use darling::ast::Fields;
use proc_macro2::TokenStream;
use syn::{parse_quote, spanned::Spanned, Ident, Path};

use crate::rpc::args::{BackendField, BackendInput};
use crate::{get_private, get_zod};
use quote::{format_ident, quote, quote_spanned};

pub fn expand(input: BackendInput, fields: Fields<BackendField>) -> TokenStream {
    let __private = get_private();
    let ident = input.ident;
    let req_ident = format_ident!("{}Req", ident);

    let backend_impl = expand_backend_impl(&ident, &req_ident, &fields);
    let req_enum = expand_req_enum(&req_ident, &fields);
    let req_enum_impl = expand_req_enum_impl(&ident, &req_ident, &fields);

    quote! {
        const _: () = {
            #backend_impl

            #req_enum

            #req_enum_impl
        };
    }
}

fn expand_backend_impl(
    ident: &Ident,
    req_ident: &Ident,
    fields: &Fields<BackendField>,
) -> TokenStream {
    let zod = get_zod();
    let __private = get_private();

    let namespaces = fields.iter().map(|f| {
        let ty = &f.ty;
        quote_spanned!(ty.span() => <#ty as #zod::Namespace>::NAME)
    });

    quote_spanned! {
        ident.span() =>
        #[#__private::async_trait::async_trait]
        impl #__private::server::Backend for #ident {
            const NS_NAMES: &'static[&'static str] = &[#(#namespaces),*];

            async fn handle_request(
                &mut self,
                req: #__private::Request,
                sender: #__private::ResponseSender,
                subscribers: &mut #__private::server::SubscriberMap,
            ) {
                match req {
                    #__private::Request::Exec { id, value } => {
                        match #__private::serde_json::from_value::<#req_ident>(value) {
                            ::std::result::Result::<_, _>::Ok(evt) => {
                                if let Some(jh) = evt.call(id, self, sender).await {
                                    subscribers.insert(id, jh);
                                }
                            }
                            ::std::result::Result::<_, _>::Err(err) => {
                                let _ = sender
                                    .unbounded_send(#__private::Response::error(id, err))
                                    .ok();
                            }
                        }
                    }
                    #__private::Request::CancelStream { id } => {
                        if let Some(jh) = subscribers.remove(&id) {
                            jh.abort();
                        }
                    }
                }
            }
        }
    }
}

pub fn expand_req_enum(ident: &Ident, fields: &Fields<BackendField>) -> TokenStream {
    let __private = get_private();
    let req_variants = fields.iter().map(|f| {
        let ty = &f.ty;
        let variant_ident = variant_ident_from_ty(ty);
        quote_spanned!(ty.span() => #variant_ident(<#ty as #__private::codegen::RpcNamespace>::Req))
    });
    quote! {

        #[derive(#__private::serde::Deserialize, Debug)]
        #[serde(tag = "namespace")]
        enum #ident {
            #(#req_variants),*
        }
    }
}

pub fn expand_req_enum_impl(
    backend_ident: &Ident,
    req_ident: &Ident,
    fields: &Fields<BackendField>,
) -> TokenStream {
    let __private = get_private();

    let req_call_dispatch = fields.iter().enumerate().map(|(index, f)| {
        let ty = &f.ty;
        let variant_ident = variant_ident_from_ty(ty);
        let field_or_index = f.ident.clone().map(|ident| quote!(#ident)).unwrap_or_else(|| {
            let index = syn::Index::from(index);
            quote!(#index)
        });

        quote_spanned!(ty.span() => #req_ident :: #variant_ident(req) => req.call(id, &mut backend.#field_or_index, sender).await)
    });

    quote_spanned! {
        req_ident.span() =>
        impl #req_ident {
            pub async fn call(
                self,
                id: usize,
                backend: &mut #backend_ident,
                sender: #__private::ResponseSender,
            ) -> ::std::option::Option<#__private::tokio::task::JoinHandle<()>> {
                match self {
                    #(#req_call_dispatch),*
                }
            }
        }
    }
}

fn variant_ident_from_ty(ty: &syn::Type) -> Ident {
    let p: Path = parse_quote!(#ty);
    p.segments.last().expect("one segment").ident.clone()
}