update

Author: hhstore

crates/rs-tauri-vue/src-tauri/Cargo.toml

@@ -19,6 +19,8 @@ rust-version = "1.57"
 members = []
 
 
+################################################################################
+
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -44,7 +46,7 @@ once_cell = "1"
 parking_lot = "0"
 
 # i18n
-rust-i18n = "0"
+rust-i18n = "1"
 sys-locale = "0"
 
 # encrypted kv:
@@ -66,6 +68,13 @@ anyhow = "1"
 # debug tool:
 console-subscriber = "0"
 
+################################################################################
+
+#
+# workspace internal dependencies:
+#
+rs-pkg = { path = "../../rs-pkg" }
+
 
 ################################################################################
 
@@ -86,6 +95,7 @@ available-locales = ["en", "zh-CN", "zh-HK", "fr"]
 # Path for your translations YAML file, default: "locales".
 # load-path = "locales"
 
+################################################################################
 
 [features]
 # by default Tauri runs in production mode

crates/rs-tauri-vue/src-tauri/src/ctx/mod.rs

@@ -3,9 +3,11 @@ use std::sync::Arc;
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 
+use rs_pkg::x::SqliteClient;
+
 use crate::{
     config::AppConfig,
-    storage::{db::SqlConn, AppEncryptedKVStorage, AppKvStorage},
+    storage::{AppEncryptedKVStorage, AppKvStorage},
 };
 
 #[derive(Clone)]
@@ -25,15 +27,15 @@ pub struct AppContext {
     pub kv_enc: Arc<Mutex<AppEncryptedKVStorage>>,
 
     // sqlite3
-    pub sql: Arc<Mutex<SqlConn>>,
+    pub sql: Arc<Mutex<SqliteClient>>,
 }
 
 impl AppContext {
     // 单例模式:
     pub async fn global() -> &'static AppContext {
         static DATA: OnceCell<AppContext> = OnceCell::new();
 
-        let sql = SqlConn::default().await;
+        let sql = SqliteClient::default().await;
 
         DATA.get_or_init(|| AppContext {
             config: Arc::new(Mutex::new(AppConfig::default())),

crates/rs-tauri-vue/src-tauri/src/storage/sql/db.rs

@@ -1,121 +1,20 @@
-use std::str::FromStr;
+use rs_pkg::x::SqliteClient;
 
-use sqlx::{
-    migrate::Migrator,
-    sqlite::{SqliteConnectOptions, SqlitePool, SqlitePoolOptions},
-    Acquire, ConnectOptions, Executor,
-};
-use tracing::info;
-
-use crate::{storage::todo::TodoSqlScope, util};
+use crate::storage::todo::TodoSqlScope;
 
 // sql storage biz
 pub struct AppSqlStorage {
-    g: SqlConn,
+    g: SqliteClient,
 
     // biz units:
     pub todo: TodoSqlScope,
 }
 
 impl AppSqlStorage {
     pub async fn new() -> Self {
-        let g = SqlConn::default().await;
-
-        // g.init_migrations().await;
+        let g = SqliteClient::default().await;
 
         let todo = TodoSqlScope::new(g.clone());
         Self { g, todo }
     }
 }
-
-// kv存储方案: SqlConn
-pub struct SqlConn {
-    pub conn: SqlitePool,
-}
-
-impl Clone for SqlConn {
-    fn clone(&self) -> Self {
-        Self { conn: self.conn.clone() }
-    }
-}
-
-impl SqlConn {
-    pub async fn default() -> Self {
-        Self::new("app.db").await
-    }
-
-    pub async fn new(db_name: &str) -> Self {
-        let conn = new_sql_conn(db_name).await;
-        Self { conn }
-    }
-
-    pub async fn init_migrations(&mut self) {
-        // todo x: 自动执行 db migrations
-        let m = Migrator::new(std::path::Path::new("./migrations"))
-            .await
-            .expect("migrations failed");
-
-        match m.run(&self.conn).await {
-            Ok(_) => {
-                println!("migrations run success");
-            },
-            Err(e) => {
-                panic!("migrations run error: {:?}", e);
-            },
-        }
-    }
-}
-
-async fn new_sql_conn(db_name: &str) -> SqlitePool {
-    let mut _root_dir = tauri::api::path::document_dir();
-
-    // sqlite:tmp/app.db
-    // let url = env::var("").unwrap_or(util::app_cfg::get_local_sqlite_url(Some(db_name)));
-    let url = util::app_cfg::get_local_sqlite_url(Some(db_name));
-    println!("sqlite url: {}", url);
-
-    // todo x: 仅用于创建 db 文件
-    let _ = SqliteConnectOptions::from_str(&url)
-        .unwrap()
-        .create_if_missing(true)
-        .connect()
-        .await
-        .expect("connect to sqlite failed");
-
-    // connect pool
-    let conn = SqlitePoolOptions::new().min_connections(2).connect(&url).await;
-
-    match conn {
-        Ok(conn) => {
-            // todo x: 初始化表结构
-            sqlx::migrate!("./migrations").run(&conn).await.expect("migrate failed");
-
-            info!("connect to sqlite db success");
-            conn
-        },
-        Err(e) => {
-            panic!("connect to sqlite db failed: {}", e);
-        },
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use tokio;
-
-    use super::*;
-
-    #[tokio::test]
-    async fn test_sqlite() {
-        let mut db = SqlConn::default().await;
-        // db.init_migrations().await;
-
-        println!("test sqlite success");
-    }
-
-    #[test]
-    fn test2() {
-        info!("hello");
-        println!("test2 success");
-    }
-}

crates/rs-tauri-vue/src-tauri/src/storage/sql/todo.rs

@@ -1,19 +1,21 @@
 use sqlx::{Acquire, Executor, Row, Statement};
 use tracing::info;
 
-use crate::{proto::TodoEntity, storage::db::SqlConn};
+use rs_pkg::x::SqliteClient;
+
+use crate::proto::TodoEntity;
 
 pub struct TodoSqlScope {
-    pub g: SqlConn,
+    pub g: SqliteClient,
 }
 
 impl TodoSqlScope {
-    pub fn new(g: SqlConn) -> Self {
+    pub fn new(g: SqliteClient) -> Self {
         Self { g }
     }
 
     pub async fn add_todo(&self, todo: &TodoEntity) -> anyhow::Result<i64> {
-        let mut conn = self.g.conn.acquire().await?;
+        let mut conn = self.g.cli.acquire().await?;
 
         // Insert the task, then obtain the ID of this row
         let id = sqlx::query(
@@ -33,29 +35,8 @@ impl TodoSqlScope {
         Ok(id)
     }
 
-    // pub async fn add_todo2(&self, todo: &TodoEntity) -> anyhow::Result<i64> {
-    //     let mut conn = self.g.conn.acquire().await?;
-    //
-    //     // Insert the task, then obtain the ID of this row
-    //     let id = sqlx::query!(
-    //         r#"
-    //     INSERT INTO todos ( description, title )
-    //     VALUES ( ?1, ?2 )
-    //             "#,
-    //         todo.description,
-    //         todo.title
-    //     )
-    //     .execute(&mut conn)
-    //     .await?
-    //     .last_insert_rowid();
-    //
-    //     info!("add todo: {:?}", todo);
-    //
-    //     Ok(id)
-    // }
-
     pub async fn list_todo(&self) -> anyhow::Result<Vec<TodoEntity>> {
-        let mut conn = self.g.conn.acquire().await?;
+        let mut conn = self.g.cli.acquire().await?;
 
         let rows = sqlx::query(
             r#"
@@ -83,7 +64,7 @@ impl TodoSqlScope {
     }
 
     pub async fn get_todo(&self, id: i64) -> anyhow::Result<TodoEntity> {
-        let mut conn = self.g.conn.acquire().await?;
+        let mut conn = self.g.cli.acquire().await?;
 
         let row = sqlx::query(
             r#"SELECT id, title, description, completed FROM todos WHERE id =
@@ -112,7 +93,7 @@ mod test {
     use super::*;
 
     async fn setup() -> TodoSqlScope {
-        let mut db = SqlConn::new("app.db").await;
+        let mut db = SqliteClient::new(None, None).await;
         // let mut db = SqlConn::default().await;
         // db.init_migrations().await;