feat: update dependencies and enhance configuration loading for CORS support

infra/src/db.rs

@@ -1,4 +1,4 @@
-pub use k_core::db::{DatabaseConfig, DatabasePool};
+pub use k_core::db::DatabasePool;
 
 pub async fn run_migrations(pool: &DatabasePool) -> Result<(), sqlx::Error> {
     match pool {

infra/src/factory.rs

@@ -5,6 +5,8 @@ use crate::SqliteUserRepository;
 use crate::db::DatabasePool;
 use domain::UserRepository;
 
+use k_core::session::store::InfraSessionStore;
+
 #[derive(Debug, thiserror::Error)]
 pub enum FactoryError {
     #[error("Database error: {0}")]
@@ -35,20 +37,14 @@ pub async fn build_user_repository(pool: &DatabasePool) -> FactoryResult<Arc<dyn
 pub async fn build_session_store(
     pool: &DatabasePool,
 ) -> FactoryResult<crate::session_store::InfraSessionStore> {
-    match pool {
+    Ok(match pool {
         #[cfg(feature = "sqlite")]
-        DatabasePool::Sqlite(pool) => {
-            let store = tower_sessions_sqlx_store::SqliteStore::new(pool.clone());
-            Ok(crate::session_store::InfraSessionStore::Sqlite(store))
+        DatabasePool::Sqlite(p) => {
+            InfraSessionStore::Sqlite(tower_sessions_sqlx_store::SqliteStore::new(p.clone()))
         }
         #[cfg(feature = "postgres")]
-        DatabasePool::Postgres(pool) => {
-            let store = tower_sessions_sqlx_store::PostgresStore::new(pool.clone());
-            Ok(crate::session_store::InfraSessionStore::Postgres(store))
+        DatabasePool::Postgres(p) => {
+            InfraSessionStore::Postgres(tower_sessions_sqlx_store::PostgresStore::new(p.clone()))
         }
-        #[allow(unreachable_patterns)]
-        _ => Err(FactoryError::NotImplemented(
-            "No database feature enabled".to_string(),
-        )),
-    }
+    })
 }

infra/src/lib.rs

@@ -20,6 +20,6 @@ pub mod session_store;
 mod user_repository;
 
 // Re-export for convenience
-pub use db::{DatabaseConfig, run_migrations};
+pub use db::run_migrations;
 #[cfg(feature = "sqlite")]
 pub use user_repository::SqliteUserRepository;

infra/src/session_store.rs

@@ -1,73 +1 @@
-use async_trait::async_trait;
-use sqlx;
-use tower_sessions::{
-    SessionStore,
-    session::{Id, Record},
-};
-#[cfg(feature = "postgres")]
-use tower_sessions_sqlx_store::PostgresStore;
-#[cfg(feature = "sqlite")]
-use tower_sessions_sqlx_store::SqliteStore;
-
-#[derive(Clone, Debug)]
-pub enum InfraSessionStore {
-    #[cfg(feature = "sqlite")]
-    Sqlite(SqliteStore),
-    #[cfg(feature = "postgres")]
-    Postgres(PostgresStore),
-}
-
-#[async_trait]
-impl SessionStore for InfraSessionStore {
-    async fn save(&self, session_record: &Record) -> tower_sessions::session_store::Result<()> {
-        match self {
-            #[cfg(feature = "sqlite")]
-            Self::Sqlite(store) => store.save(session_record).await,
-            #[cfg(feature = "postgres")]
-            Self::Postgres(store) => store.save(session_record).await,
-            #[allow(unreachable_patterns)]
-            _ => Err(tower_sessions::session_store::Error::Backend(
-                "No backend enabled".to_string(),
-            )),
-        }
-    }
-
-    async fn load(&self, session_id: &Id) -> tower_sessions::session_store::Result<Option<Record>> {
-        match self {
-            #[cfg(feature = "sqlite")]
-            Self::Sqlite(store) => store.load(session_id).await,
-            #[cfg(feature = "postgres")]
-            Self::Postgres(store) => store.load(session_id).await,
-            #[allow(unreachable_patterns)]
-            _ => Err(tower_sessions::session_store::Error::Backend(
-                "No backend enabled".to_string(),
-            )),
-        }
-    }
-
-    async fn delete(&self, session_id: &Id) -> tower_sessions::session_store::Result<()> {
-        match self {
-            #[cfg(feature = "sqlite")]
-            Self::Sqlite(store) => store.delete(session_id).await,
-            #[cfg(feature = "postgres")]
-            Self::Postgres(store) => store.delete(session_id).await,
-            #[allow(unreachable_patterns)]
-            _ => Err(tower_sessions::session_store::Error::Backend(
-                "No backend enabled".to_string(),
-            )),
-        }
-    }
-}
-
-impl InfraSessionStore {
-    pub async fn migrate(&self) -> Result<(), sqlx::Error> {
-        match self {
-            #[cfg(feature = "sqlite")]
-            Self::Sqlite(store) => store.migrate().await,
-            #[cfg(feature = "postgres")]
-            Self::Postgres(store) => store.migrate().await,
-            #[allow(unreachable_patterns)]
-            _ => Err(sqlx::Error::Configuration("No backend enabled".into())),
-        }
-    }
-}
+pub use k_core::session::store::InfraSessionStore;

infra/src/user_repository.rs

@@ -141,18 +141,17 @@ impl UserRepository for SqliteUserRepository {
 #[cfg(all(test, feature = "sqlite"))]
 mod tests {
     use super::*;
-    use crate::db::{DatabaseConfig, DatabasePool, run_migrations};
-    use k_core::db::connect; // Import k_core::db::connect
+    use crate::db::run_migrations;
+    use k_core::db::{DatabaseConfig, DatabasePool, connect};
 
     async fn setup_test_db() -> SqlitePool {
         let config = DatabaseConfig::default();
-        // connect returns DatabasePool directly now
         let db_pool = connect(&config).await.expect("Failed to create pool");
+
         run_migrations(&db_pool).await.unwrap();
-        // Extract SqlitePool from DatabasePool for SqliteUserRepository
+
         match db_pool {
             DatabasePool::Sqlite(pool) => pool,
-            _ => panic!("Expected SqlitePool for testing"),
         }
     }