saas-rs-sdk 0.6.6

The SaaS RS SDK
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

#![allow(clippy::all)]
#![allow(dead_code)]

#[allow(unused)]
pub const FILE_DESCRIPTOR_SET: &[u8] = tonic::include_file_descriptor_set!("proto_descriptor");

pub mod acme {
    pub mod user {
        pub mod v1 {
            use saas_rs_sdk::storage::associations::{BelongsTo, HasMany};
            use std::collections::HashMap;
            use strum::IntoEnumIterator;
            use strum_macros::{AsRefStr, Display, EnumIter, EnumString};

            include!("generated/acme.user.v1.rs");
            include!("generated/acme.user.v1.serde.rs");

            #[derive(AsRefStr, Clone, Debug, Display, EnumIter, EnumString)]
            pub enum Bucket {
                #[strum(serialize = "accessTokens")]
                AccessTokens,
                #[strum(serialize = "accounts")]
                Accounts,
                #[strum(serialize = "linkedAccounts")]
                LinkedAccounts,
                #[strum(serialize = "refreshTokens")]
                RefreshTokens,
                #[strum(serialize = "typeSaladBooleanTypes")]
                TypeSaladBooleanTypes,
                #[strum(serialize = "typeSaladCharacterTypes")]
                TypeSaladCharacterTypes,
                #[strum(serialize = "typeSaladNumericArbitraryPrecisionTypes")]
                TypeSaladNumericArbitraryPrecisionTypes,
                #[strum(serialize = "typeSaladNumericFloatingPointTypes")]
                TypeSaladNumericFloatingPointTypes,
                #[strum(serialize = "typeSaladNumericIntegerTypes")]
                TypeSaladNumericIntegerTypes,
                #[strum(serialize = "typeSaladNumericSerialTypes")]
                TypeSaladNumericSerialTypes,
                #[strum(serialize = "typeSaladUuidTypes")]
                TypeSaladUuidTypes,
            }

            fn get_belongs_tos(bucket: Bucket) -> Vec<BelongsTo<Bucket>> {
                match bucket {
                    Bucket::LinkedAccounts => vec![BelongsTo {
                        remote: Bucket::Accounts,
                        local: "ownerAccountId".to_string(),
                        inverse: Some("linkedAccountIds".to_string()),
                    }],
                    _ => vec![],
                }
            }

            #[allow(unused)]
            pub fn get_belongs_tos_by_bucket() -> HashMap<String, Vec<BelongsTo<Bucket>>> {
                let mut map = HashMap::new();
                for bucket in Bucket::iter() {
                    map.insert(bucket.to_string(), get_belongs_tos(bucket));
                }
                map
            }

            fn get_has_manys(bucket: Bucket) -> Vec<HasMany<Bucket>> {
                match bucket {
                    Bucket::Accounts => vec![HasMany {
                        remote: Bucket::LinkedAccounts,
                        local: "linkedAccountIds".to_string(),
                        inverse: Some("ownerAccountId".to_string()),
                    }],
                    _ => vec![],
                }
            }

            #[allow(unused)]
            pub fn get_has_manys_by_bucket() -> HashMap<String, Vec<HasMany<Bucket>>> {
                let mut map = HashMap::new();
                for bucket in Bucket::iter() {
                    map.insert(bucket.to_string(), get_has_manys(bucket));
                }
                map
            }
        }
    }
}

#[allow(unused)]
pub fn deserialize<T: prost::Message + Default>(buf: &[u8]) -> Result<T, prost::DecodeError> {
    T::decode(&mut std::io::Cursor::new(buf))
}

#[allow(unused)]
pub fn serialize<T: prost::Message>(message: &T) -> Result<Vec<u8>, prost::EncodeError> {
    let mut buf = Vec::with_capacity(message.encoded_len());
    message.encode(&mut buf)?;
    Ok(buf)
}