增加最sea-orm的支持

Author: ipconfiger

Cargo.lock

@@ -25,5 +25,8 @@ libaes = "0.7.0"
 utoipa = { version = "5.3.1", features = ["axum_extras"] }
 utoipa-rapidoc = { version = "6.0.0", features = ["axum"] }
 aliyun-sts-rust-sdk = { version ="0.1.1", path="/Users/alex/Projects/workspace/aliyun-sts-rust-sdk"}
-sqlx = { version = "0.7.4", default-features = false, features = ["tls-rustls", "runtime-tokio", "postgres", "json", "uuid", "bigdecimal", "macros"] }
-sqlx_struct_enhanced = { version = "*", path = "/Users/alex/Projects/workspace/sqlx_struct_enhanced", features = ["postgres"] }
+sea-orm = { version = "1.1.10" , features = ["runtime-tokio", "sqlx-all"] }
+sqlx-postgres = "0.8.5"
+
+[dev-dependencies]
+sea-orm-cli = "1.1.10"

Cargo.toml

@@ -9,31 +9,27 @@ use axum::routing::get;
 //use http::{header, Request, StatusCode};
 use log::{error, info};
 use serde_json::json;
-use sqlx::postgres::PgPoolOptions;
 use utoipa::OpenApi;
 use utoipa_rapidoc::RapiDoc;
 use crate::errors::ErrResponse;
 use crate::conf::Configuration;
 use crate::{example, services};
 use crate::redis::{RedisHolder, RedisSession};
 use redis::AsyncCommands;
+use sea_orm::Database;
 
 #[derive(Clone)]
 pub struct AppContext {}
 
 pub async fn init(cfg: &Configuration) {
-    let pool = PgPoolOptions::new()
-        .max_connections(5)
-        .acquire_timeout(Duration::from_secs(3))
-        .connect(&cfg.db_uri.clone())
-        .await
-        .expect("can't connect to database");
+    let db = Database::connect(cfg.db_uri.as_str()).await.unwrap();
+    
     let client = redis::Client::open(cfg.redis_uri.clone()).unwrap();
     let client_inner = client.clone();
     ru_di::Di::register(move |_| {
         RedisHolder{client: client_inner.clone()}
     });
-    let pool_inner = pool.clone();
+    let pool_inner = db.clone();
     ru_di::Di::register(move |_| {
         pool_inner.clone()
     });

src/app.rs

@@ -1,7 +1,7 @@
 use axum::Json;
 use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
-use sqlx::Error;
+use sea_orm::DbErr;
 use reqwest::Error as HttpError;
 use redis::RedisError;
 use log::error;
@@ -24,7 +24,7 @@ pub(crate) struct ErrResponse {
 #[derive(Debug)]
 pub enum AppError {
     DbError {
-        source:Error,
+        source:DbErr,
         backtrace: Backtrace,
     },
     RedisError { 
@@ -48,8 +48,8 @@ pub enum AppError {
     LoginFailure,
 }
 
-impl From<Error> for AppError {
-    fn from(value: Error) -> Self {
+impl From<DbErr> for AppError {
+    fn from(value: DbErr) -> Self {
         error!("数据库错误:{:?}", value);
         Self::DbError{ source: value, backtrace: Backtrace::capture()}
     }
@@ -126,19 +126,19 @@ impl IntoResponse for AppError {
         eprintln!("Error: {}", self);
         let resp = match self {
             Self::DbError { source, backtrace}=>{
-                if let Error::RowNotFound = source {
-                    //error!("查询记录不存在：{:?} {:?}", source, backtrace);
-                    (
-                        StatusCode::NOT_FOUND,
-                        Json(json!(ErrResponse{info: format!("{source:?}")}))
-                    )
-                }else{
-                    //error!("数据库错误:{:?} {:?}", source, backtrace);
-                    (
-                        StatusCode::INTERNAL_SERVER_ERROR,
-                        Json(json!(ErrResponse{info: format!("{source:?}")}))
-                    )
-                   
+                match source {
+                    DbErr::RecordNotFound(_) => {
+                        (
+                            StatusCode::NOT_FOUND,
+                            Json(json!(ErrResponse{info: format!("{source:?}")}))
+                        )
+                    }
+                    _=>{
+                        (
+                            StatusCode::INTERNAL_SERVER_ERROR,
+                            Json(json!(ErrResponse{info: format!("{source:?}")}))
+                        )
+                    }
                 }
             },
             Self::LogicError(msg)=>{

src/errors.rs

@@ -22,8 +22,8 @@ use crate::response::StatusResponse;
 )]
 async fn it_works() -> APIResult<StatusResponse> {
     let serv = get_serve::<ExampleServices>();
-    serv.test().await?;
-    Ok(Json(StatusResponse{status: "it works".to_string()}))
+    let resp = serv.test().await?;
+    Ok(Json(StatusResponse{status: resp}))
 }
 
 // 导出路由

src/example/handlers.rs

@@ -1,17 +1,23 @@
-use sqlx::FromRow;
-use sqlx_struct_enhanced::{EnhancedCrud, Scheme};
-use sqlx::query::{Query, QueryAs};
-use sqlx::Postgres;
-use sqlx::database::HasArguments;
-use uuid::Uuid;
-use sqlx::types::BigDecimal;
 
+pub mod UserLogin {
+    use sea_orm::entity::prelude::*;
+    use sea_orm::{ActiveModelTrait, Database, DbErr, DeleteResult, EntityTrait, Set};
+    use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, FromRow, EnhancedCrud)]
-pub struct UserLogin {
-    pub username: String,
-    pub password: String,
-    pub ts: i32,
-    
+    #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Deserialize, Serialize)]
+    #[sea_orm(table_name = "user_login")]
+    pub struct Model {
+        #[sea_orm(primary_key)]
+        pub username: String,
+        
+        pub password: String,
+        pub ts: i32,
+        
+    }
+
+    #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+    pub enum Relation {}
+    impl ActiveModelBehavior for ActiveModel {}
 }
 
+

src/models.rs

@@ -1,15 +1,9 @@
-use axum::Json;
-use axum::response::IntoResponse;
-use sqlx::Error;
-use serde_json::json;
-use redis::RedisError;
-use reqwest::Error as HttpError;
-use log::error;
 use serde::{Deserialize, Serialize};
-use serde_json::{Error as JsonError, Value};
+use serde_json::Value;
 use utoipa::ToSchema;
 
 
+
 #[derive(Debug, Clone, ToSchema, Deserialize, Serialize)]
 pub struct StatusResponse {
     pub status: String,

src/response.rs

@@ -1,27 +1,28 @@
 use log::info;
-use sqlx_struct_enhanced::EnhancedCrud;
-use crate::errors::APIResult;
-use crate::models::UserLogin;
+use sea_orm::{DatabaseConnection, EntityTrait};
+use crate::errors::{APIResult, AppError};
 use crate::redis::RedisHolder;
 use crate::types::Service;
 use crate::utilities::current_ts;
+use crate::models::UserLogin::{ActiveModel, Entity};
 
 pub struct ExampleServices {
-    pub(crate) db: sqlx::Pool<sqlx::Postgres>,
+    pub(crate) db: DatabaseConnection,
     pub(crate) redis: RedisHolder,
 }
 
 impl Service for ExampleServices {
-    fn init(db: sqlx::Pool<sqlx::Postgres>, redis: RedisHolder) -> Self {
+    fn init(db: DatabaseConnection, redis: RedisHolder) -> Self {
         Self{db, redis}
     }
 }
 
 impl ExampleServices {
-    pub(crate) async fn test(&self) -> APIResult<()> {
-        let user = UserLogin::where_query("name=$1").bind("test").fetch_one(&self.db).await?;
-        info!("Running test:{:?}", user);
-        Ok(())
+    pub(crate) async fn test(&self) -> APIResult<String> {
+        if let Some(entity) = Entity::find_by_id::<String>("Alex".to_string()).one(&self.db).await? {
+            Ok(entity.username.to_string())
+        } else {
+            Err(AppError::NotFound)
+        }
     }
-
 }

src/services/example_service.rs

@@ -1,4 +1,5 @@
 use axum::Json;
+use sea_orm::DatabaseConnection;
 use crate::errors::AppError;
 use crate::redis::RedisHolder;
 
@@ -9,12 +10,12 @@ pub fn get_serve<T: 'static>() -> T {
 }
 
 pub trait Service {
-    fn init(db: sqlx::Pool<sqlx::Postgres>, redis: RedisHolder) -> Self;
+    fn init(db: DatabaseConnection, redis: RedisHolder) -> Self;
 }
 
 pub fn register_service<T: Service + 'static + Send + Sync>() {
     ru_di::Di::register(move |di| {
-        let db = di.get_inner::<sqlx::Pool<sqlx::Postgres>>().unwrap();
+        let db = di.get_inner::<DatabaseConnection>().unwrap();
         let redis = di.get_inner::<RedisHolder>().unwrap();
         T::init(db, redis)
     });

src/types.rs

@@ -1,15 +1,22 @@
-use sqlx::FromRow;
-use sqlx_struct_enhanced::{EnhancedCrud, Scheme};
-use sqlx::query::{Query, QueryAs};
-use sqlx::Postgres;
-use sqlx::database::HasArguments;
-use uuid::Uuid;
-use sqlx::types::BigDecimal;
-
 {% for entity in entities %}
-#[derive(Debug, Clone, FromRow, EnhancedCrud)]
-pub struct {{ entity.name }} {
-    {% for fd in entity.fields %}pub {{fd.name}}: {{ fd.types.rust.name }},
-    {% endfor %}
+pub mod {{ entity.name }} {
+    use sea_orm::entity::prelude::*;
+    use sea_orm::{ActiveModelTrait, Database, DbErr, DeleteResult, EntityTrait, Set};
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Deserialize, Serialize)]
+    #[sea_orm(table_name = "{{ entity.name | snake_case }}")]
+    pub struct Model {
+        #[sea_orm(primary_key)]
+        {% for fd in entity.fields | slice(start=0, end=1) %}pub {{fd.name}}: {{ fd.types.rust.name }},
+        {% endfor %}
+        {% for fd in entity.fields | slice(start=1) %}pub {{fd.name}}: {{ fd.types.rust.name }},
+        {% endfor %}
+    }
+
+    #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+    pub enum Relation {}
+    impl ActiveModelBehavior for ActiveModel {}
 }
+
 {% endfor %}