added database_pool crate, for pool handling and migrations

crates/database_pool/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "database_pool"
+version = "0.0.0"
+edition = "2021"
+
+[dependencies.sqlx]
+workspace = true
+features = ["sqlite", "migrate", "runtime-tokio-rustls"]

crates/database_pool/src/lib.rs

@@ -0,0 +1,50 @@
+//! # Initialize database pool connection
+//!
+//! ```
+//! use database_pool::Pool;
+//!
+//! # async fn get_database() {
+//! let database = Pool::init("/path/to/database.sqlite").await.expect("Failed to init pool");
+//!
+//! // Close pool
+//! database.close().await;
+//! # }
+//! ```
+//!
+//! # Run migrations to pool
+//!
+//! ```
+//! use database_pool::Pool;
+//! use database_pool::run_migrations;
+//!
+//! # async fn migrations() {
+//! # let database = Pool::init("/path/to/database.sqlite").await.unwrap();
+//! run_migrations(&database.pool).await.expect("Failed to run migrations");
+//! # }
+//! ```
+//!
+//! # Run transaction on database
+//!
+//! ```
+//! use database_pool::Pool;
+//!
+//! # async fn run_transaction() {
+//! # let database = Pool::init("/path/to/database.sqlite").await.unwrap();
+//! // Start transaction
+//! let mut transaction = database.pool.begin().await.expect("Failed to start transaction");
+//!
+//! // Run functions requiring database
+//!
+//! // Commit transaction
+//! transaction.commit().await.expect("Failed to commit transaction");
+//!
+//! // Do what you need :)
+//!
+//! # }
+//! ```
+
+mod migrations;
+mod pool;
+
+pub use migrations::run_migrations;
+pub use pool::Pool;

crates/database_pool/src/migrations.rs

@@ -0,0 +1,15 @@
+use sqlx::migrate::MigrateError;
+use sqlx::{Pool, Sqlite};
+
+pub async fn run_migrations(pool: &Pool<Sqlite>) -> Result<(), MigrateError> {
+    match sqlx::migrate!("../database").run(pool).await {
+        Ok(ok) => {
+            println!("Migrations are OK");
+            Ok(ok)
+        }
+        Err(e) => {
+            eprintln!("Failed to run migrations!");
+            Err(e)
+        }
+    }
+}

crates/database_pool/src/pool.rs

@@ -0,0 +1,29 @@
+use sqlx::sqlite::SqlitePoolOptions;
+use sqlx::{Error, Pool as SqlxPool, Sqlite};
+
+pub struct Pool {
+    url: String,
+    pub pool: SqlxPool<Sqlite>,
+}
+
+impl Pool {
+    /// Initializes a new connection pool to database
+    ///
+    /// # Arguments
+    ///
+    /// * `url` - Path to SQLite database, must be full path
+    pub async fn init(url: impl Into<String>) -> Result<Self, Error> {
+        let url = url.into();
+        let pool = SqlitePoolOptions::new().connect(&url).await?;
+
+        println!("SQLite pool established for `{url}`");
+
+        Ok(Self { url, pool })
+    }
+
+    /// Close connection pool to database
+    pub async fn close(&self) {
+        self.pool.close().await;
+        println!("SQLite pool closed for `{}`", self.url);
+    }
+}

crates/ezidam/Cargo.toml

@@ -8,3 +8,6 @@ rocket = "0.5.0-rc.2"
 rocket_db_pools = { version = "0.1.0-rc.2", features = ["sqlx_sqlite"] }
 rocket_dyn_templates = { version = "0.1.0-rc.2", features = ["tera"] }
 infer = { version = "0.12.0", default-features = false }
+
+# local crates
+database_pool = { path = "../database_pool" }

crates/ezidam/Rocket.toml

@@ -0,0 +1,2 @@
+[default.databases.ezidam]
+url = "../../database/ezidam.sqlite"

crates/ezidam/src/database.rs

@@ -0,0 +1,36 @@
+use database_pool::run_migrations;
+use rocket::fairing::AdHoc;
+use rocket::{error, fairing, info, Build, Rocket};
+use rocket_db_pools::{sqlx, Database as RocketDatabase};
+
+#[derive(RocketDatabase)]
+#[database("ezidam")]
+pub struct Database(sqlx::SqlitePool);
+
+impl Database {
+    pub fn rocket(rocket_builder: Rocket<Build>) -> Rocket<Build> {
+        rocket_builder
+            // Init
+            .attach(Self::init())
+            // SQL Migrations
+            .attach(AdHoc::try_on_ignite("SQL Startup", Self::startup))
+    }
+
+    async fn startup(rocket: Rocket<Build>) -> fairing::Result {
+        let Some(db) = Self::fetch(&rocket) else {
+            error!("Failed to get database");
+            return Err(rocket);
+        };
+
+        match run_migrations(&db.0).await {
+            Ok(()) => {
+                info!("Migrations ran successfully");
+                Ok(rocket)
+            }
+            Err(e) => {
+                error!("Failed to run migrations: {}", e);
+                Err(rocket)
+            }
+        }
+    }
+}

crates/ezidam/src/main.rs

@@ -1,3 +1,4 @@
+mod database;
 mod shutdown;
 
 // see for using rocket with main function https://github.com/intellij-rust/intellij-rust/issues/5975#issuecomment-920620289
@@ -6,6 +7,9 @@ async fn main() -> std::result::Result<(), rocket::Error> {
     // Build server
     let rocket_builder = rocket::build();
 
+    // Database
+    let rocket_builder = database::Database::rocket(rocket_builder);
+
     // Shutdown
     let rocket_builder = shutdown::shutdown(rocket_builder);