init

libertas_api/src/factory.rs

@@ -0,0 +1,105 @@
+use std::sync::Arc;
+
+use libertas_core::{
+    error::{CoreError, CoreResult},
+    repositories::UserRepository,
+};
+use sqlx::{Pool, Postgres, Sqlite};
+
+use crate::{
+    config::{Config, DatabaseConfig, DatabaseType},
+    repositories::user_repository::{PostgresUserRepository, SqliteUserRepository},
+    security::{Argon2Hasher, JwtGenerator},
+    services::{
+        album_service::AlbumServiceImpl, media_service::MediaServiceImpl,
+        user_service::UserServiceImpl,
+    },
+    state::AppState,
+};
+
+#[derive(Clone)]
+enum DatabasePool {
+    Postgres(Pool<Postgres>),
+    Sqlite(Pool<Sqlite>),
+}
+
+pub async fn build_app_state(config: Config) -> CoreResult<AppState> {
+    let db_pool = build_database_pool(&config.database).await?;
+
+    let user_repo = build_user_repository(&config.database, db_pool.clone()).await?;
+    let media_repo = build_media_repository(&config.database, db_pool.clone()).await?;
+    let album_repo = build_album_repository(&config.database, db_pool.clone()).await?;
+
+    let hasher = Arc::new(Argon2Hasher::default());
+    let tokenizer = Arc::new(JwtGenerator::new(config.jwt_secret.clone()));
+
+    let user_service = Arc::new(UserServiceImpl::new(user_repo, hasher, tokenizer.clone()));
+    let media_service = Arc::new(MediaServiceImpl::new(media_repo.clone(), config.clone()));
+    let album_service = Arc::new(AlbumServiceImpl::new(album_repo, media_repo));
+
+    Ok(AppState {
+        user_service,
+        media_service,
+        album_service,
+        token_generator: tokenizer,
+    })
+}
+
+async fn build_database_pool(db_config: &DatabaseConfig) -> CoreResult<DatabasePool> {
+    match db_config.db_type {
+        DatabaseType::Postgres => {
+            let pool = sqlx::postgres::PgPoolOptions::new()
+                .max_connections(50)
+                .connect(&db_config.url)
+                .await
+                .map_err(|e| CoreError::Database(e.to_string()))?;
+            Ok(DatabasePool::Postgres(pool))
+        }
+        DatabaseType::Sqlite => {
+            let pool = sqlx::sqlite::SqlitePoolOptions::new()
+                .max_connections(2)
+                .connect(&db_config.url)
+                .await
+                .map_err(|e| CoreError::Database(e.to_string()))?;
+            Ok(DatabasePool::Sqlite(pool))
+        }
+    }
+}
+
+async fn build_user_repository(
+    _db_config: &DatabaseConfig,
+    pool: DatabasePool,
+) -> CoreResult<Arc<dyn UserRepository>> {
+    match pool {
+        DatabasePool::Postgres(pg_pool) => Ok(Arc::new(PostgresUserRepository::new(pg_pool))),
+        DatabasePool::Sqlite(sqlite_pool) => Ok(Arc::new(SqliteUserRepository::new(sqlite_pool))),
+    }
+}
+
+async fn build_media_repository(
+    _db_config: &DatabaseConfig,
+    pool: DatabasePool,
+) -> CoreResult<Arc<dyn libertas_core::repositories::MediaRepository>> {
+    match pool {
+        DatabasePool::Postgres(pg_pool) => Ok(Arc::new(
+            crate::repositories::media_repository::PostgresMediaRepository::new(pg_pool),
+        )),
+        DatabasePool::Sqlite(_sqlite_pool) => Err(CoreError::Database(
+            "Sqlite media repository not implemented".to_string(),
+        )),
+    }
+}
+
+async fn build_album_repository(
+    _db_config: &DatabaseConfig,
+    pool: DatabasePool,
+) -> CoreResult<Arc<dyn libertas_core::repositories::AlbumRepository>> {
+    match pool {
+        DatabasePool::Postgres(pg_pool) => Ok(Arc::new(
+            crate::repositories::album_repository::PostgresAlbumRepository::new(pg_pool),
+        )),
+        DatabasePool::Sqlite(_sqlite_pool) => Err(CoreError::Database(
+            "Sqlite album repository not implemented".to_string(),
+        )),
+    }
+}