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

use super::field;
use proc_macro2::TokenStream;
use quote::{quote, quote_spanned};
use serde_derive_internals::{ast, attr::TagType};
use syn::Ident;

/// represents a struct variant of an enum, it has one or more named fields. It is represeneted as
/// an object in typescript.
pub struct StructVariant<'a> {
    pub ident: &'a Ident,
    pub fields: field::VariantFields<'a>,
    pub serde_ast: &'a ast::Container<'a>,
    pub attrs: &'a serde_derive_internals::attr::Variant,
}

impl<'a> StructVariant<'a> {
    pub fn expand_schema(&self) -> TokenStream {
        let inner = match self.fields.len() {
            0 => unreachable!("Empty tuple structs are handled by darling"),
            1 => {
                let inner = self.fields.expand_schema();
                inner.first().expect("one field").clone()
            }

            _ => {
                let inner = self.fields.expand_schema();
                quote! {
                    {
                        let inner: std::vec::Vec<String> = vec![#(#inner),*];
                        inner.join(", ")
                    }
                }
            }
        };

        let span = self.ident.span();
        let name = self.attrs.name().deserialize_name();

        match self.serde_ast.attrs.tag() {
            TagType::External => {
                quote_spanned! {span =>  format!("z.object({{ {}: z.object({{ {} }}) }})", #name, #inner) }
            }
            TagType::Internal { tag } => {
                quote_spanned! {span =>  format!("z.object({{ {}: z.literal(\"{}\"), {} }})", #tag, #name, #inner) }
            }
            TagType::Adjacent { tag, content } => {
                quote_spanned! {span =>  format!("z.object({{ {}: z.literal(\"{}\"), {}: z.object({{ {} }}) }})", #tag, #name, #content, #inner) }
            }
            TagType::None => {
                quote_spanned! {span =>  format!("z.object({{ {} }})", #inner) }
            }
        }
    }

    pub fn expand_type_defs(&self) -> TokenStream {
        let expanded_fields = self.fields.expand_type_defs();
        let span = self.ident.span();
        let name = self.attrs.name().deserialize_name();

        let inner = match expanded_fields.len() {
            0 => unreachable!("Empty tuple structs are handled by darling"),
            1 => expanded_fields
                .first()
                .expect("exactly one variant")
                .clone(),

            _ => {
                quote! {
                    {
                        let inner: std::vec::Vec<String> = vec![#(#expanded_fields),*];
                        inner.join(", ")
                    }
                }
            }
        };

        match self.serde_ast.attrs.tag() {
            // `A{ num: usize, s: String }` -> `{ A: { num: number, s: string } }`
            TagType::External => {
                quote_spanned! {span =>  format!("{{ {}: {{ {} }} }}", #name, #inner) }
            }
            // `A{ num: usize, s: String }` -> `{ type: "A", num: number, s: string }`
            TagType::Internal { tag } => {
                quote_spanned! {span =>  format!("{{ {}: \"{}\", {} }}", #tag, #name, #inner) }
            }

            // `A{ num: usize, s: String }` -> `{ type: "A", content: { num: number, s: string }}`
            TagType::Adjacent { tag, content } => {
                quote_spanned! {span =>  format!("{{ {}: \"{}\", {}: {{ {} }} }}", #tag, #name, #content, #inner) }
            }
            // `A{ num: usize, s: String }` -> `{ num: number, s: string }`
            TagType::None => {
                quote_spanned! {span =>  format!("{{ {} }}", #inner) }
            }
        }
    }
}