dynamic-graphql-derive 0.10.2

Dynamic GraphQL schema macro
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
136
137
138
139
140

use darling::FromMeta;
use inflector::Inflector;

#[derive(Debug, Copy, Clone, FromMeta)]
pub enum RenameRule {
    #[darling(rename = "lowercase")]
    Lower,
    #[darling(rename = "UPPERCASE")]
    Upper,
    #[darling(rename = "PascalCase")]
    Pascal,
    #[darling(rename = "camelCase")]
    Camel,
    #[darling(rename = "snake_case")]
    Snake,
    #[darling(rename = "SCREAMING_SNAKE_CASE")]
    ScreamingSnake,
}

impl RenameRule {
    fn rename(&self, name: impl AsRef<str>) -> String {
        match self {
            Self::Lower => name.as_ref().to_lowercase(),
            Self::Upper => name.as_ref().to_uppercase(),
            Self::Pascal => name.as_ref().to_pascal_case(),
            Self::Camel => name.as_ref().to_camel_case(),
            Self::Snake => name.as_ref().to_snake_case(),
            Self::ScreamingSnake => name.as_ref().to_screaming_snake_case(),
        }
    }
}

#[allow(dead_code)]
#[derive(Debug, Copy, Clone)]
pub enum RenameTarget {
    Type,
    EnumItem,
    Field,
    Argument,
}

impl RenameTarget {
    fn rule(&self) -> RenameRule {
        match self {
            RenameTarget::Type => RenameRule::Pascal,
            RenameTarget::EnumItem => RenameRule::ScreamingSnake,
            RenameTarget::Field => RenameRule::Camel,
            RenameTarget::Argument => RenameRule::Camel,
        }
    }

    pub fn rename(&self, name: impl AsRef<str>) -> String {
        self.rule().rename(name)
    }
}

pub trait RenameRuleExt {
    fn rename(&self, name: impl AsRef<str>, target: RenameTarget) -> String;
}

impl RenameRuleExt for Option<RenameRule> {
    fn rename(&self, name: impl AsRef<str>, target: RenameTarget) -> String {
        self.unwrap_or(target.rule()).rename(name)
    }
}

impl RenameRuleExt for Option<&RenameRule> {
    fn rename(&self, name: impl AsRef<str>, target: RenameTarget) -> String {
        self.unwrap_or(&target.rule()).rename(name)
    }
}

/// Calculate the name of a field.
/// @arg name: The name of the field, specified by the user.
/// @arg ident_name: The name of the field, extracted from the code.
pub fn calc_field_name(
    name: Option<&str>,
    ident_name: &str,
    rename_rule: Option<&RenameRule>,
) -> String {
    match name {
        Some(name) => name.to_owned(),
        None => match rename_rule {
            Some(rename_fields) => rename_fields.rename(ident_name),
            None => RenameTarget::Field.rename(ident_name),
        },
    }
}

pub fn calc_input_field_name(
    name: Option<&str>,
    ident_name: &str,
    rename_rule: Option<&RenameRule>,
) -> String {
    match name {
        Some(name) => name.to_owned(),
        None => match rename_rule {
            Some(rename_fields) => rename_fields.rename(ident_name),
            None => RenameTarget::Argument.rename(ident_name),
        },
    }
}

/// Calculate the name of a type.
/// @arg name: The name of the type, specified by the user.
/// @arg type_name: The name of the type, extracted from the code.
pub fn calc_type_name(name: Option<&str>, type_name: &str) -> String {
    match name {
        Some(name) => name.to_owned(),
        None => RenameTarget::Type.rename(type_name),
    }
}

pub fn calc_enum_item_name(
    name: Option<&str>,
    item_name: &str,
    rename_rule: Option<&RenameRule>,
) -> String {
    match name {
        Some(name) => name.to_owned(),
        None => match rename_rule {
            Some(rename_items) => rename_items.rename(item_name),
            None => RenameTarget::EnumItem.rename(item_name),
        },
    }
}

pub fn calc_arg_name(
    name: Option<&str>,
    ident_name: &str,
    rename_rule: Option<&RenameRule>,
) -> String {
    match name {
        Some(name) => name.to_owned(),
        None => {
            let ident_name = ident_name.strip_prefix('_').unwrap_or(ident_name);
            rename_rule.rename(ident_name, RenameTarget::Argument)
        }
    }
}