♻️ 进一步分割之前定义的一堆枚举，把 JWT 和 bcrypt 先单独拎出来。

Author: langyo

Cargo.lock

@@ -1,74 +1,74 @@
 pub mod models;
 
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result};
 use log::info;
 use minio::s3::types::S3Api;
 use once_cell::sync::Lazy;
-use std::{
-    sync::{Arc, Mutex},
-    time::Duration,
-};
+use std::{sync::Arc, time::Duration};
 
 use sea_orm::{ConnectOptions, Database, DatabaseConnection};
 
-pub static PG_CONN: Lazy<Arc<Mutex<Option<DatabaseConnection>>>> =
-    Lazy::new(|| Arc::new(Mutex::new(None)));
-pub static REDIS_CONN: Lazy<Arc<Mutex<Option<redis::Client>>>> =
-    Lazy::new(|| Arc::new(Mutex::new(None)));
-pub static MINIO_CONN: Lazy<Arc<Mutex<Option<minio::s3::Client>>>> =
-    Lazy::new(|| Arc::new(Mutex::new(None)));
+#[derive(Debug, Clone)]
+pub struct DatabaseConnectionMap {
+    pub pg_conn: DatabaseConnection,
+    pub redis_conn: redis::Client,
+    pub minio_conn: minio::s3::Client,
+}
 
-pub async fn init() -> Result<()> {
-    PG_CONN
-        .lock()
-        .map_err(|err| anyhow!(format!("Failed to lock PG_CONN: {}", err)))?
-        .replace(
-            Database::connect({
-                let mut opt = ConnectOptions::new(format!(
-                    "postgres://{}:{}@{}:{}/{}",
-                    std::env::var("DB_USERNAME").unwrap_or("genshin_map".into()),
-                    std::env::var("DB_PASSWORD").unwrap_or("".into()),
-                    std::env::var("DB_HOST").unwrap_or("localhost".into()),
-                    std::env::var("DB_PORT")
-                        .map(|str| str.parse::<u16>().unwrap())
-                        .unwrap_or(5432),
-                    std::env::var("DB_DATABASE").unwrap_or("genshin_map".into()),
-                ));
-                opt.max_connections(100)
-                    .min_connections(5)
-                    .connect_timeout(Duration::from_secs(8))
-                    .acquire_timeout(Duration::from_secs(8))
-                    .idle_timeout(Duration::from_secs(8))
-                    .max_lifetime(Duration::from_secs(8))
-                    .sqlx_logging(true)
-                    .sqlx_logging_level(log::LevelFilter::Trace);
-                opt
-            })
-            .await?,
-        );
-    info!("Postgres is ready");
+pub static DB_CONN: Lazy<Arc<DatabaseConnectionMap>> = Lazy::new(|| {
+    Arc::new({
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("Failed to create Tokio runtime")
+            .block_on(init())
+            .expect("Failed to initialize database connections")
+    })
+});
 
-    REDIS_CONN
-        .lock()
-        .map_err(|err| anyhow!(format!("Failed to lock REDIS_CONN: {}", err)))?
-        .replace(redis::Client::open(format!(
-            "redis://{}{}@{}:{}/{}",
-            std::env::var("REDIS_USERNAME").unwrap_or("".into()),
-            std::env::var("REDIS_PASSWORD")
-                .map(|p| format!(":{}", p))
-                .unwrap_or_default(),
-            std::env::var("REDIS_HOST").unwrap_or("localhost".into()),
-            std::env::var("REDIS_PORT")
+pub async fn init() -> Result<DatabaseConnectionMap> {
+    // Postgres
+    let pg_conn = {
+        let mut opt = ConnectOptions::new(format!(
+            "postgres://{}:{}@{}:{}/{}",
+            std::env::var("DB_USERNAME").unwrap_or("genshin_map".into()),
+            std::env::var("DB_PASSWORD").unwrap_or("".into()),
+            std::env::var("DB_HOST").unwrap_or("localhost".into()),
+            std::env::var("DB_PORT")
                 .map(|str| str.parse::<u16>().unwrap())
-                .unwrap_or(6379),
-            1,
-        ))?);
+                .unwrap_or(5432),
+            std::env::var("DB_DATABASE").unwrap_or("genshin_map".into()),
+        ));
+        opt.max_connections(100)
+            .min_connections(5)
+            .connect_timeout(Duration::from_secs(8))
+            .acquire_timeout(Duration::from_secs(8))
+            .idle_timeout(Duration::from_secs(8))
+            .max_lifetime(Duration::from_secs(8))
+            .sqlx_logging(true)
+            .sqlx_logging_level(log::LevelFilter::Trace);
+        Database::connect(opt).await?
+    };
+    info!("Postgres is ready");
+
+    // Redis
+    let redis_conn = redis::Client::open(format!(
+        "redis://{}{}@{}:{}/{}",
+        std::env::var("REDIS_USERNAME").unwrap_or("".into()),
+        std::env::var("REDIS_PASSWORD")
+            .map(|p| format!(":{}", p))
+            .unwrap_or_default(),
+        std::env::var("REDIS_HOST").unwrap_or("localhost".into()),
+        std::env::var("REDIS_PORT")
+            .map(|str| str.parse::<u16>().unwrap())
+            .unwrap_or(6379),
+        1,
+    ))?;
     info!("Redis is ready");
 
-    MINIO_CONN
-        .lock()
-        .map_err(|err| anyhow!(format!("Failed to lock MINIO_CONN: {}", err)))?
-        .replace(minio::s3::Client::new(
+    // MinIO
+    let minio_conn = {
+        let client = minio::s3::Client::new(
             std::env::var("MINIO_BASE_URL")
                 .unwrap_or("http://localhost:9000".into())
                 .parse()?,
@@ -79,57 +79,40 @@ pub async fn init() -> Result<()> {
             ))),
             None,
             None,
-        )?);
-    if let Some(conn) = MINIO_CONN
-        .lock()
-        .map_err(|err| anyhow!(format!("Failed to lock MINIO_CONN: {}", err)))?
-        .as_mut()
-    {
-        if !conn.bucket_exists("images").send().await?.exists {
-            conn.create_bucket("images").send().await?;
-            let config = serde_json::json!({
-                "Version": "2012-10-17",
-                "Statement": [
-                    {
-                        "Effect": "Allow",
-                        "Principal": "*",
-                        "Action": [
-                            "s3:GetObject"
-                        ],
-                        "Resource": "arn:aws:s3:::images/*"
-                    }
-                ]
-            })
-            .to_string();
-            conn.put_bucket_policy("images")
-                .config(config)
-                .send()
-                .await?;
-        }
+        )?;
 
-        if !conn.bucket_exists("bz2doc").send().await?.exists {
-            conn.create_bucket("bz2doc").send().await?;
-            let config = serde_json::json!({
-                "Version": "2012-10-17",
-                "Statement": [
-                    {
-                        "Effect": "Allow",
-                        "Principal": "*",
-                        "Action": [
-                            "s3:GetObject"
-                        ],
-                        "Resource": "arn:aws:s3:::bz2doc/*"
-                    }
-                ]
-            })
-            .to_string();
-            conn.put_bucket_policy("bz2doc")
-                .config(config)
-                .send()
-                .await?;
+        // Ensure buckets exist and set policy
+        for bucket in ["images", "bz2doc"] {
+            if !client.bucket_exists(bucket).send().await?.exists {
+                client.create_bucket(bucket).send().await?;
+                let config = serde_json::json!({
+                    "Version": "2012-10-17",
+                    "Statement": [
+                        {
+                            "Effect": "Allow",
+                            "Principal": "*",
+                            "Action": [
+                                "s3:GetObject"
+                            ],
+                            "Resource": format!("arn:aws:s3:::{}/*", bucket)
+                        }
+                    ]
+                })
+                .to_string();
+                client
+                    .put_bucket_policy(bucket)
+                    .config(config)
+                    .send()
+                    .await?;
+            }
         }
-    }
+        client
+    };
     info!("MinIO is ready");
 
-    Ok(())
+    Ok(DatabaseConnectionMap {
+        pg_conn,
+        redis_conn,
+        minio_conn,
+    })
 }

packages/database/src/lib.rs

@@ -1,7 +1,7 @@
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use _utils::types::enums::HiddenFlag;
+use _utils::types::HiddenFlag;
 
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Deserialize, Serialize)]
 #[sea_orm(table_name = "area", schema_name = "genshin_map")]

packages/database/src/models/area/area.rs

@@ -1,7 +1,7 @@
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use _utils::types::enums::{HistoryEditType, HistoryOperationType};
+use _utils::types::{HistoryEditType, HistoryOperationType};
 
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Deserialize, Serialize)]
 #[sea_orm(table_name = "history", schema_name = "genshin_map")]

packages/database/src/models/common/history.rs

@@ -1,7 +1,7 @@
 use sea_orm::{entity::prelude::*, FromJsonQueryResult};
 use serde::{Deserialize, Serialize};
 
-use _utils::types::enums::HiddenFlag;
+use _utils::types::HiddenFlag;
 
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Deserialize, Serialize)]
 #[sea_orm(table_name = "route", schema_name = "genshin_map")]

packages/database/src/models/common/route.rs

@@ -1,7 +1,7 @@
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use _utils::types::enums::ScopeStatType;
+use _utils::types::ScopeStatType;
 
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Deserialize, Serialize)]
 #[sea_orm(table_name = "score_stat", schema_name = "genshin_map")]

packages/database/src/models/common/score_stat.rs

@@ -1,7 +1,7 @@
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use _utils::types::enums::{HiddenFlag, IconStyleType};
+use _utils::types::{HiddenFlag, IconStyleType};
 
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Deserialize, Serialize)]
 #[sea_orm(table_name = "item", schema_name = "genshin_map")]

packages/database/src/models/item/item.rs

@@ -1,7 +1,7 @@
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use _utils::types::enums::HiddenFlag;
+use _utils::types::HiddenFlag;
 
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Deserialize, Serialize)]
 #[sea_orm(table_name = "item_type", schema_name = "genshin_map")]

packages/database/src/models/item/item_type.rs

@@ -1,7 +1,7 @@
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use _utils::types::enums::HiddenFlag;
+use _utils::types::HiddenFlag;
 
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Deserialize, Serialize)]
 #[sea_orm(table_name = "marker", schema_name = "genshin_map")]

packages/database/src/models/marker/marker.rs

@@ -1,7 +1,7 @@
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use _utils::types::enums::MarkerLinkageLinkAction;
+use _utils::types::MarkerLinkageLinkAction;
 
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Deserialize, Serialize)]
 #[sea_orm(table_name = "marker_linkage", schema_name = "genshin_map")]