forklaunch 1.15.0

Launch faster with forklaunch
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 std::collections::HashSet;

use anyhow::{Result, bail};

use crate::constants::{Module, get_service_module_name};

#[derive(Debug, PartialEq, Eq)]
pub(crate) enum IamConfig {
    BetterAuthIam,
    BaseIam,
}

#[derive(Debug, PartialEq, Eq)]
pub(crate) enum BillingConfig {
    BaseBilling,
    StripeBilling,
}

#[derive(Debug, PartialEq, Eq)]
pub(crate) enum EcommerceConfig {
    StripeEcommerce,
}

#[derive(Debug, PartialEq, Eq)]
pub(crate) enum MessagingConfig {
    BaseMessaging,
    TwilioMessaging,
}

#[derive(Debug, PartialEq, Eq)]
pub(crate) enum CacConfig {
    BaseCac,
}

#[derive(Debug, PartialEq, Eq)]
pub(crate) enum RelayConfig {
    Relay,
}

#[derive(Debug, PartialEq, Eq, Default)]
pub(crate) struct ModuleConfig {
    pub(crate) iam: Option<IamConfig>,
    pub(crate) billing: Option<BillingConfig>,
    pub(crate) ecommerce: Option<EcommerceConfig>,
    pub(crate) messaging: Option<MessagingConfig>,
    pub(crate) cac: Option<CacConfig>,
    pub(crate) relay: Option<RelayConfig>,
}

pub(crate) fn validate_modules(
    modules: &Vec<Module>,
    global_module_config: &mut ModuleConfig,
) -> Result<()> {
    let mut module_conflict_set = HashSet::new();

    for module in modules {
        match module {
            Module::BetterAuthIam => {
                global_module_config.iam = Some(IamConfig::BetterAuthIam);
            }
            Module::BaseIam => {
                global_module_config.iam = Some(IamConfig::BaseIam);
            }
            Module::BaseBilling => {
                global_module_config.billing = Some(BillingConfig::BaseBilling);
            }
            Module::StripeBilling => {
                global_module_config.billing = Some(BillingConfig::StripeBilling);
            }
            Module::StripeEcommerce => {
                global_module_config.ecommerce = Some(EcommerceConfig::StripeEcommerce);
            }
            Module::BaseMessaging => {
                global_module_config.messaging = Some(MessagingConfig::BaseMessaging);
            }
            Module::TwilioMessaging => {
                global_module_config.messaging = Some(MessagingConfig::TwilioMessaging);
            }
            Module::BaseCac => {
                global_module_config.cac = Some(CacConfig::BaseCac);
            }
            Module::Relay => {
                global_module_config.relay = Some(RelayConfig::Relay);
            }
        }

        let module_type = get_service_module_name(module);

        if module_conflict_set.contains(&module_type) {
            bail!("Module conflict");
        }

        module_conflict_set.insert(module_type);
    }

    Ok(())
}