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

use super::field;
use super::UnitVariant;
use proc_macro2::Span;
use proc_macro2::TokenStream;
use quote::{quote, quote_spanned};
use serde_derive_internals::attr::TagType;

/// represents a tuple variant of an enum, it has one or more unnamed fields. It is represented as a tuple in
/// zod which is a const array in typescript
pub struct TupleVariant<'a> {
    pub span: Span,
    pub tag: &'a TagType,
    pub name: String,
    pub fields: field::VariantFields<'a>,
}

impl<'a> TupleVariant<'a> {
    pub fn expand_schema(&self) -> TokenStream {
        let inner = match self.fields.len() {
            0 => {
                // may occur if fields are skipped. In this case we handle it like a unit variant
                return UnitVariant {
                    span: self.span,
                    tag: self.tag,
                    name: self.name.clone(),
                }
                .expand_schema();
            }
            1 => self
                .fields
                .expand_schema()
                .into_iter()
                .next()
                .expect("one field"),

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

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

    pub fn expand_type_defs(&self) -> TokenStream {
        let expanded_fields = self.fields.expand_type_defs();
        let span = self.span;
        let tag_type = self.tag;
        let name = &self.name;

        let inner = match expanded_fields.len() {
            // may occur if fields are skipped. In this case we handle it like a unit variant
            0 => {
                return UnitVariant {
                    span: self.span,
                    tag: self.tag,
                    name: self.name.clone(),
                }
                .expand_type_defs()
            }
            1 => expanded_fields
                .first()
                .expect("exactly one variant")
                .clone(),

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

        match tag_type {
            TagType::External | TagType::Internal { .. } => {
                quote_spanned! {span =>  format!("{{ {}: {} }}", #name, #inner) }
            }
            TagType::Adjacent { tag, content } => {
                quote_spanned! {span =>  format!("{{ {}: \"{}\", {}: {} }}", #tag, #name, #content, #inner) }
            }
            TagType::None => {
                quote_spanned! {span =>  #inner }
            }
        }
    }
}