feat: expand workspace to include libertas_infra and libertas_worker

feat(libertas_api): add dependency on libertas_infra and async-nats

refactor(libertas_api): consolidate config loading and add broker_url

refactor(libertas_api): integrate NATS client into app state and services

feat(libertas_core): introduce config module for database and server settings

fix(libertas_core): enhance error handling with detailed messages

feat(libertas_infra): create infrastructure layer with database repositories

feat(libertas_infra): implement Postgres repositories for media and albums

feat(libertas_worker): add worker service to process media jobs via NATS

libertas_api/src/factory.rs

@@ -1,14 +1,14 @@
 use std::sync::Arc;
 
 use libertas_core::{
+    config::Config,
     error::{CoreError, CoreResult},
-    repositories::UserRepository,
 };
-use sqlx::{Pool, Postgres, Sqlite};
+use libertas_infra::factory::{
+    build_album_repository, build_database_pool, build_media_repository, build_user_repository,
+};
 
 use crate::{
-    config::{Config, DatabaseConfig, DatabaseType},
-    repositories::user_repository::{PostgresUserRepository, SqliteUserRepository},
     security::{Argon2Hasher, JwtGenerator},
     services::{
         album_service::AlbumServiceImpl, media_service::MediaServiceImpl,
@@ -17,13 +17,12 @@ use crate::{
     state::AppState,
 };
 
-#[derive(Clone)]
-enum DatabasePool {
-    Postgres(Pool<Postgres>),
-    Sqlite(Pool<Sqlite>),
-}
-
 pub async fn build_app_state(config: Config) -> CoreResult<AppState> {
+    let nats_client = async_nats::connect(&config.broker_url)
+        .await
+        .map_err(|e| CoreError::Config(format!("Failed to connect to NATS: {}", e)))?;
+    println!("API connected to NATS at {}", config.broker_url);
+
     let db_pool = build_database_pool(&config.database).await?;
 
     let user_repo = build_user_repository(&config.database, db_pool.clone()).await?;
@@ -34,7 +33,11 @@ pub async fn build_app_state(config: Config) -> CoreResult<AppState> {
     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 media_service = Arc::new(MediaServiceImpl::new(
+        media_repo.clone(),
+        config.clone(),
+        nats_client.clone(),
+    ));
     let album_service = Arc::new(AlbumServiceImpl::new(album_repo, media_repo));
 
     Ok(AppState {
@@ -42,64 +45,6 @@ pub async fn build_app_state(config: Config) -> CoreResult<AppState> {
         media_service,
         album_service,
         token_generator: tokenizer,
+        nats_client,
     })
 }
-
-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(),
-        )),
-    }
-}