Switched from diesel to sqlx

src/database/mod.rs

@@ -0,0 +1,81 @@
+use std::{sync::OnceLock, time::Duration};
+
+use redis::{aio::MultiplexedConnection as RedisConnection, Client as RedisClient, RedisResult};
+use sqlx::{postgres::PgPoolOptions, Pool, Postgres};
+use crate::error::SirenResult;
+
+static POOL: OnceLock<Pool<Postgres>> = OnceLock::new();
+static REDIS: OnceLock<RedisClient> = OnceLock::new();
+
+pub async fn initialize() -> SirenResult<()> {
+  log::info!("Initializing database...");
+  let db_user = std::env::var("DATABASE_USER").unwrap_or("siren".to_string());
+  let db_password = std::env::var("DATABASE_PASSWORD").expect("DATABASE_PASSWORD must be set");
+  let db_host: String = std::env::var("DATABASE_HOST").expect("DATABASE_HOST must be set");
+  let db_port = std::env::var("DATABASE_PORT").unwrap_or("5432".to_string());
+  let db_name = std::env::var("DATABASE_NAME").unwrap_or("siren".to_string());
+
+  // Setup Postgres pool connection
+  let pool = PgPoolOptions::new()
+    .max_connections(5)
+    .acquire_timeout(Duration::from_secs(30))
+    .connect(&format!(
+      "postgres://{}:{}@{}:{}/{}",
+      db_user, db_password, db_host, db_port, db_name
+    ))
+    .await?;
+  match POOL.set(pool) {
+    Ok(_) => {}
+    Err(_) => {
+      log::warn!("Database pool already initialized");
+    }
+  }
+
+  // Setup Redis connection
+  let redis = {
+    let host = std::env::var("REDIS_HOST").unwrap_or("localhost".to_string());
+    let port = std::env::var("REDIS_PORT").unwrap_or("6379".to_string());
+    let url = format!("redis://{}:{}", host, port);
+    RedisClient::open(url).expect("Failed to create redis client")
+  };
+  match REDIS.set(redis) {
+    Ok(_) => {}
+    Err(_) => {
+      log::warn!("Redis client already initialized");
+    }
+  }
+
+  // Run migrations
+  match run_migrations().await {
+    Ok(_) => log::debug!("Successfully ran migrations"),
+    Err(e) => log::error!("Failed to run migrations: {}", e),
+  }
+
+  log::info!("Database initialized");
+  Ok(())
+}
+
+pub fn pool() -> &'static Pool<Postgres> {
+  POOL.get().unwrap()
+}
+
+fn redis() -> &'static RedisClient {
+  REDIS.get().unwrap()
+}
+
+pub fn redis_connection() -> RedisResult<redis::Connection> {
+  let conn = redis().get_connection()?;
+  Ok(conn)
+}
+
+pub async fn redis_async_connection() -> RedisResult<RedisConnection> {
+  let conn = redis().get_multiplexed_async_connection().await?;
+  Ok(conn)
+}
+
+async fn run_migrations() -> SirenResult<()> {
+  log::debug!("Running migrations");
+  let pool = pool();
+  sqlx::migrate!().run(pool).await?;
+  Ok(())
+}