forklaunch 1.11.2

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use convert_case::{Case, Casing};
use ramhorns::Content;
use serde::{Deserialize, Serialize};

use super::{InitializableManifestConfig, InitializableManifestConfigMetadata, ProjectType};
use crate::{config_struct, constants::Database, core::database::get_db_driver};

config_struct!(
    #[derive(Debug, Content, Serialize, Clone)]
    pub(crate) struct RouterManifestData {
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) router_name: String,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) camel_case_name: String,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) pascal_case_name: String,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) kebab_case_name: String,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) title_case_name: String,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) is_database_enabled: bool,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) database: String,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) db_driver: String,

        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) is_postgres: bool,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) is_mongo: bool,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) is_mysql: bool,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) is_mariadb: bool,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) is_mssql: bool,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) is_sqlite: bool,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) is_better_sqlite: bool,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) is_libsql: bool,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) is_in_memory_database: bool,

        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) is_worker: bool,

        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) is_cache_enabled: bool,
        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) is_s3_enabled: bool,

        #[serde(skip_serializing, skip_deserializing)]
        pub(crate) otel_token: String,
    }
);

impl InitializableManifestConfig for RouterManifestData {
    fn initialize(&self, metadata: InitializableManifestConfigMetadata) -> Self {
        let router_metadata = match metadata {
            InitializableManifestConfigMetadata::Router(router_metadata) => router_metadata,
            _ => unreachable!(),
        };
        let project_name = router_metadata.project_name.clone();
        let router_name = router_metadata.router_name.unwrap().clone();
        let project_entry = self
            .projects
            .iter()
            .find(|p| p.name == project_name)
            .unwrap();
        let database = project_entry
            .resources
            .as_ref()
            .unwrap()
            .database
            .clone()
            .unwrap();
        let parsed_database = database.parse::<Database>().unwrap();

        Self {
            router_name: router_name.clone(),
            camel_case_name: router_name.to_case(Case::Camel),
            pascal_case_name: router_name.to_case(Case::Pascal),
            kebab_case_name: router_name.to_case(Case::Kebab),
            database: database.clone(),
            db_driver: get_db_driver(&parsed_database),

            is_postgres: parsed_database == Database::PostgreSQL,
            is_mongo: parsed_database == Database::MongoDB,
            is_mysql: parsed_database == Database::MySQL,
            is_mariadb: parsed_database == Database::MariaDB,
            is_mssql: parsed_database == Database::MsSQL,
            is_sqlite: parsed_database == Database::SQLite,
            is_better_sqlite: parsed_database == Database::BetterSQLite,
            is_libsql: parsed_database == Database::LibSQL,
            is_in_memory_database: parsed_database == Database::SQLite
                || parsed_database == Database::BetterSQLite
                || parsed_database == Database::LibSQL,

            is_worker: matches!(project_entry.r#type, ProjectType::Worker),

            is_cache_enabled: project_entry.resources.as_ref().unwrap().cache.is_some(),
            is_s3_enabled: project_entry
                .resources
                .as_ref()
                .unwrap()
                .object_store
                .is_some(),

            otel_token: "OtelCollector".to_string(),

            ..self.clone()
        }
    }
}