seaography/enumerations/
active_enum.rs

1use async_graphql::dynamic::Enum;
2use heck::ToUpperCamelCase;
3use sea_orm::{ActiveEnum, DynIden, Value};
4
5use crate::BuilderContext;
6
7/// The configuration structure for ActiveEnumBuilder
8pub struct ActiveEnumConfig {
9    /// used to format enumeration name
10    pub type_name: crate::SimpleNamingFn,
11    /// used to format variant name
12    pub variant_name: crate::ComplexNamingFn,
13}
14
15impl std::default::Default for ActiveEnumConfig {
16    fn default() -> Self {
17        ActiveEnumConfig {
18            type_name: Box::new(|name: &str| -> String {
19                format!("{}Enum", name.to_upper_camel_case())
20            }),
21            variant_name: Box::new(|_enum_name: &str, variant: &str| -> String {
22                format_variant(variant)
23            }),
24        }
25    }
26}
27
28/// This builder is used to convert a SeaORM enumeration to GraphQL
29pub struct ActiveEnumBuilder {
30    pub context: &'static BuilderContext,
31}
32
33impl ActiveEnumBuilder {
34    /// used to format SeaORM enumeration name to GraphQL enumeration name
35    pub fn type_name<A: ActiveEnum>(&self) -> String {
36        let name = A::name().to_string();
37        self.context.active_enum.type_name.as_ref()(&name)
38    }
39
40    /// used to format enumeration Iden name to GraphQL enumeration name
41    pub fn type_name_from_iden(&self, name: &DynIden) -> String {
42        let name = name.to_string();
43        self.context.active_enum.type_name.as_ref()(&name)
44    }
45
46    /// used to format SeaORM variant name to GraphQL variant name
47    pub fn variant_name(&self, enum_name: &str, variant: &str) -> String {
48        self.context.active_enum.variant_name.as_ref()(enum_name, variant)
49    }
50
51    /// used to convert SeaORM enumeration to GraphQL enumeration
52    pub fn enumeration<A: ActiveEnum>(&self) -> Enum {
53        let enum_name = self.type_name::<A>();
54
55        A::values()
56            .into_iter()
57            .fold(Enum::new(&enum_name), |enumeration, variant| {
58                let variant: Value = variant.into();
59                let variant: String = variant.to_string();
60                enumeration.item(self.variant_name(&enum_name, &variant))
61            })
62    }
63}
64
65pub(crate) fn format_variant(variant: &str) -> String {
66    variant
67        .chars()
68        .filter(|&c| c.is_ascii_alphanumeric() || c == '_')
69        .collect()
70}