update

Author: hhstore

Taskfile.yml

@@ -36,6 +36,9 @@ includes:
     taskfile: crates/rs-sql/rs-sqlcipher
     dir: crates/rs-sql/rs-sqlcipher
 
+  pkg:
+    taskfile: crates/rs-pkg
+    dir: crates/rs-pkg
 
 
 #

crates/rs-pkg/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+name = "rs-pkg"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[workspace]
+members = []
+
+
+[dependencies]
+tokio = { version = "1", features = ["full"] }
+anyhow = "1"
+
+serde_json = "1"
+serde = { version = "1", features = ["derive"] }
+
+# logging
+tracing = "0.1"
+tracing-subscriber = "0.3"
+
+once_cell = "1"
+parking_lot = "0"
+
+# encrypted kv:
+microkv = "0"
+
+# kv:
+pickledb = "0"
+
+sqlx = { version = "0.6", features = ["runtime-tokio-rustls", "sqlite"] }
+sqlx-rt = "0"
+#sqlx-macros = "0.6"
+#sqlx-macros = { version = "^0.6" }

crates/rs-pkg/Taskfile.yml

@@ -0,0 +1,65 @@
+version: "3"
+
+tasks:
+  init:
+    - echo "init"
+
+  dev:
+    cmds:
+      - echo "dev install"
+      - cargo install cargo-edit
+      - cargo install cargo-outdated
+      - cargo install rust-i18n
+      - cargo install tauri-cli
+
+  install:
+    cmds:
+      - task: build
+
+  build:
+    cmds:
+      - task: update
+      #      - RUST_I18N_DEBUG=1 cargo build
+      - cargo build
+
+  check:
+    cmds:
+      - cargo sqlx prepare
+      - cargo sqlx prepare --check
+    dir: "src-tauri"
+    ignore_error: true
+
+  kill:
+    cmds:
+      - fig run kill-all-processes-at-port --port 7173
+
+  test:
+    cmds:
+      - echo "test"
+      #      - task: clean:test
+      - RUST_BACKTRACE=1 RUST_LOG=debug macro_backtrace=1 cargo test -- --nocapture
+
+  update:
+    cmds:
+      - cargo outdated  # RUST_BACKTRACE=1 RUST_LOG=debug
+      - cargo upgrade # RUST_BACKTRACE=1 RUST_LOG=debug
+
+  clean:
+    cmds:
+      - cargo clean
+
+  clean:test:
+    cmds:
+      - rm *.db
+    dir: "tmp/"
+    ignore_error: true
+
+
+  release:
+    cmds:
+      - echo "release"
+      - pnpm build
+
+  fix:
+    cmds:
+      - cargo metadata --verbose --format-version 1 --all-features

crates/rs-pkg/readme.md

@@ -0,0 +1,25 @@
+# rust common utils
+
+- common utils for rust.
+- extensions for rust std lib.
+- wrappers for rust 3rd party libs.
+
+## Features:
+
+> std lib:
+
+- [ ] xxx
+
+> 3rd party libs:
+
+- [x] sqlx wrapper
+
+## Usage
+
+```toml
+
+# cargo.toml
+rs-pkg = { git = "" }
+
+
+```

crates/rs-pkg/src/lib.rs

@@ -0,0 +1,16 @@
+pub mod x;
+
+pub fn add(left: usize, right: usize) -> usize {
+    left + right
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() {
+        let result = add(2, 2);
+        assert_eq!(result, 4);
+    }
+}

crates/rs-pkg/src/x/mod.rs

@@ -0,0 +1,3 @@
+pub use storage::*;
+
+pub mod storage;

crates/rs-pkg/src/x/storage/kv.rs

@@ -0,0 +1,5 @@
+pub use kv::*;
+pub use sql::*;
+
+pub mod kv;
+pub mod sql;

crates/rs-pkg/src/x/storage/mod.rs

@@ -0,0 +1,125 @@
+use std::str::FromStr;
+
+use sqlx::{
+    migrate::Migrator,
+    sqlite::{SqliteConnectOptions, SqlitePoolOptions},
+    ConnectOptions, SqlitePool,
+};
+
+// db 存储方案: SqlClient
+pub struct SqliteClient {
+    pub cli: SqlitePool,
+}
+
+impl Clone for SqliteClient {
+    fn clone(&self) -> Self {
+        Self { cli: self.cli.clone() }
+    }
+}
+
+impl SqliteClient {
+    pub async fn default() -> Self {
+        Self::new(None, None).await
+    }
+
+    pub async fn new(db_name: Option<&str>, migrations: Option<&str>) -> Self {
+        // 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 db_url = util::fmt_local_sqlite_url(db_name);
+
+        // todo x: 仅用于创建 db 文件
+        let _ = SqliteConnectOptions::from_str(&db_url)
+            .unwrap()
+            .create_if_missing(true)
+            .connect()
+            .await
+            .expect("connect to sqlite failed");
+
+        // connect pool
+        let cli = SqlitePoolOptions::new().min_connections(2).connect(&db_url).await;
+
+        match cli {
+            Ok(c) => {
+                let dir = migrations.unwrap_or("./migrations");
+
+                // if dir exist, do migrate
+                if std::path::Path::new(dir).exists() {
+                    // todo x: 自动执行 db migrations
+                    let m =
+                        Migrator::new(std::path::Path::new(dir)).await.expect("migrations failed");
+
+                    match m.run(&c).await {
+                        Ok(_) => {
+                            println!("migrations run success");
+                        },
+                        Err(e) => {
+                            panic!("migrations run error: {:?}", e);
+                        },
+                    }
+                }
+
+                // // todo x: 初始化表结构
+                // sqlx::migrate!(migrations.unwrap_or("./migrations"))
+                //     .run(&conn)
+                //     .await
+                //     .expect("migrate failed");
+
+                Self { cli: c }
+            },
+            Err(e) => {
+                panic!("connect to sqlite db failed: {}", e);
+            },
+        }
+    }
+}
+
+pub mod util {
+    use std::{env, path::PathBuf};
+
+    pub fn local_tmp_dir() -> PathBuf {
+        let tmp_local = "tmp";
+
+        let mut current_dir = env::current_dir().expect("get current directory failed");
+        let tmp_dir = current_dir.join(tmp_local);
+        if !tmp_dir.exists() {
+            std::fs::create_dir(&tmp_dir).expect("create tmp dir failed");
+        }
+        tmp_dir
+    }
+
+    pub fn fmt_local_sqlite_url(db_name: Option<&str>) -> String {
+        let fp = db_name.unwrap_or("app.db");
+        let prefix = "sqlite:";
+        format!("{}{}", prefix, local_tmp_dir().join(fp).to_str().unwrap())
+    }
+
+    #[cfg(test)]
+    mod test {
+        use super::*;
+
+        #[test]
+        fn test_get_local_sqlite_url() {
+            let cases = [None, Some("test.db")];
+
+            // iter
+            for case in cases.iter() {
+                let url = fmt_local_sqlite_url(*case);
+                println!("url: {}", url);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use tokio;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn test_new_sqlite_client() {
+        let db = SqliteClient::default().await;
+    }
+}