refactor: remove loco-rs deps

apps/recorder/src/app/config/default_mixin.toml

@@ -14,3 +14,5 @@ leaky_bucket_refill_interval = 500
 [graphql]
 depth_limit = inf
 complexity_limit = inf
+
+[cache]

apps/recorder/src/app/config/mod.rs

@@ -7,21 +7,26 @@ use figment::{
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 
-use super::env::Enviornment;
+use super::env::Environment;
 use crate::{
-    auth::AuthConfig, errors::RResult, extract::mikan::AppMikanConfig,
-    graphql::config::GraphQLConfig, storage::StorageConfig,
+    auth::AuthConfig, cache::CacheConfig, database::DatabaseConfig, errors::RResult,
+    extract::mikan::MikanConfig, graphql::GraphQLConfig, logger::LoggerConfig,
+    storage::StorageConfig, web::WebServerConfig,
 };
 
 const DEFAULT_CONFIG_MIXIN: &str = include_str!("./default_mixin.toml");
 const CONFIG_ALLOWED_EXTENSIONS: &[&str] = &[".toml", ".json", ".yaml", ".yml"];
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AppConfig {
+    pub server: WebServerConfig,
+    pub cache: CacheConfig,
     pub auth: AuthConfig,
-    pub dal: StorageConfig,
-    pub mikan: AppMikanConfig,
+    pub storage: StorageConfig,
+    pub mikan: MikanConfig,
     pub graphql: GraphQLConfig,
+    pub logger: LoggerConfig,
+    pub database: DatabaseConfig,
 }
 
 impl AppConfig {
@@ -40,13 +45,13 @@ impl AppConfig {
             .collect_vec()
     }
 
-    pub fn priority_suffix(enviornment: &Enviornment) -> Vec<String> {
+    pub fn priority_suffix(environment: &Environment) -> Vec<String> {
         vec![
-            format!(".{}.local", enviornment.full_name()),
-            format!(".{}.local", enviornment.short_name()),
+            format!(".{}.local", environment.full_name()),
+            format!(".{}.local", environment.short_name()),
             String::from(".local"),
-            enviornment.full_name().to_string(),
-            enviornment.short_name().to_string(),
+            environment.full_name().to_string(),
+            environment.short_name().to_string(),
             String::from(""),
         ]
     }
@@ -75,4 +80,97 @@ impl AppConfig {
             _ => unreachable!("unsupported config extension"),
         })
     }
+
+    pub async fn load_dotenv(
+        environment: &Environment,
+        working_dir: &str,
+        dotenv_file: Option<&str>,
+    ) -> RResult<()> {
+        let try_dotenv_file_or_dirs = if dotenv_file.is_some() {
+            vec![dotenv_file]
+        } else {
+            vec![Some(working_dir)]
+        };
+
+        let priority_suffix = &AppConfig::priority_suffix(environment);
+        let dotenv_prefix = AppConfig::dotenv_prefix();
+        let try_filenames = priority_suffix
+            .iter()
+            .map(|ps| format!("{}{}", &dotenv_prefix, ps))
+            .collect_vec();
+
+        for try_dotenv_file_or_dir in try_dotenv_file_or_dirs.into_iter().flatten() {
+            let try_dotenv_file_or_dir_path = Path::new(try_dotenv_file_or_dir);
+            if try_dotenv_file_or_dir_path.exists() {
+                if try_dotenv_file_or_dir_path.is_dir() {
+                    for f in try_filenames.iter() {
+                        let p = try_dotenv_file_or_dir_path.join(f);
+                        if p.exists() && p.is_file() {
+                            dotenv::from_path(p)?;
+                            break;
+                        }
+                    }
+                } else if try_dotenv_file_or_dir_path.is_file() {
+                    dotenv::from_path(try_dotenv_file_or_dir_path)?;
+                    break;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    pub async fn load_config(
+        environment: &Environment,
+        working_dir: &str,
+        config_file: Option<&str>,
+    ) -> RResult<AppConfig> {
+        let try_config_file_or_dirs = if config_file.is_some() {
+            vec![config_file]
+        } else {
+            vec![Some(working_dir)]
+        };
+
+        let allowed_extensions = &AppConfig::allowed_extension();
+        let priority_suffix = &AppConfig::priority_suffix(environment);
+        let convention_prefix = &AppConfig::config_prefix();
+
+        let try_filenames = priority_suffix
+            .iter()
+            .flat_map(|ps| {
+                allowed_extensions
+                    .iter()
+                    .map(move |ext| (format!("{}{}{}", convention_prefix, ps, ext), ext))
+            })
+            .collect_vec();
+
+        let mut fig = Figment::from(AppConfig::default_provider());
+
+        for try_config_file_or_dir in try_config_file_or_dirs.into_iter().flatten() {
+            let try_config_file_or_dir_path = Path::new(try_config_file_or_dir);
+            if try_config_file_or_dir_path.exists() {
+                if try_config_file_or_dir_path.is_dir() {
+                    for (f, ext) in try_filenames.iter() {
+                        let p = try_config_file_or_dir_path.join(f);
+                        if p.exists() && p.is_file() {
+                            fig = AppConfig::merge_provider_from_file(fig, &p, ext)?;
+                            break;
+                        }
+                    }
+                } else if let Some(ext) = try_config_file_or_dir_path
+                    .extension()
+                    .and_then(|s| s.to_str())
+                    && try_config_file_or_dir_path.is_file()
+                {
+                    fig =
+                        AppConfig::merge_provider_from_file(fig, try_config_file_or_dir_path, ext)?;
+                    break;
+                }
+            }
+        }
+
+        let app_config: AppConfig = fig.extract()?;
+
+        Ok(app_config)
+    }
 }