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_infra/src/factory.rs

@@ -0,0 +1,75 @@
+use std::sync::Arc;
+
+use libertas_core::{
+    config::{DatabaseConfig, DatabaseType},
+    error::{CoreError, CoreResult},
+    repositories::UserRepository,
+};
+use sqlx::{Pool, Postgres, Sqlite};
+
+use crate::repositories::user_repository::{PostgresUserRepository, SqliteUserRepository};
+
+#[derive(Clone)]
+pub enum DatabasePool {
+    Postgres(Pool<Postgres>),
+    Sqlite(Pool<Sqlite>),
+}
+
+pub 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))
+        }
+    }
+}
+
+pub 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))),
+    }
+}
+
+pub 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(),
+        )),
+    }
+}
+
+pub 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(),
+        )),
+    }
+}

libertas_infra/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod factory;
+pub mod repositories;

libertas_infra/src/repositories/album_repository.rs

@@ -0,0 +1,91 @@
+use async_trait::async_trait;
+use libertas_core::{
+    error::{CoreError, CoreResult},
+    models::Album,
+    repositories::AlbumRepository,
+};
+use sqlx::PgPool;
+use uuid::Uuid;
+
+#[derive(Clone)]
+pub struct PostgresAlbumRepository {
+    pool: PgPool,
+}
+
+impl PostgresAlbumRepository {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait]
+impl AlbumRepository for PostgresAlbumRepository {
+    async fn create(&self, album: Album) -> CoreResult<()> {
+        sqlx::query!(
+            r#"
+            INSERT INTO albums (id, owner_id, name, description, is_public, created_at, updated_at)
+            VALUES ($1, $2, $3, $4, $5, $6, $7)
+            "#,
+            album.id,
+            album.owner_id,
+            album.name,
+            album.description,
+            album.is_public,
+            album.created_at,
+            album.updated_at
+        )
+        .execute(&self.pool)
+        .await
+        .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        Ok(())
+    }
+
+    async fn find_by_id(&self, id: Uuid) -> CoreResult<Option<Album>> {
+        sqlx::query_as!(
+            Album,
+            r#"
+            SELECT id, owner_id, name, description, is_public, created_at, updated_at
+            FROM albums
+            WHERE id = $1
+            "#,
+            id
+        )
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(|e| CoreError::Database(e.to_string()))
+    }
+
+    async fn list_by_user(&self, user_id: Uuid) -> CoreResult<Vec<Album>> {
+        sqlx::query_as!(
+            Album,
+            r#"
+            SELECT id, owner_id, name, description, is_public, created_at, updated_at
+            FROM albums
+            WHERE owner_id = $1
+            "#,
+            user_id
+        )
+        .fetch_all(&self.pool)
+        .await
+        .map_err(|e| CoreError::Database(e.to_string()))
+    }
+
+    async fn add_media_to_album(&self, album_id: Uuid, media_ids: &[Uuid]) -> CoreResult<()> {
+        // Use sqlx's `unnest` feature to pass the Vec<Uuid> efficiently
+        sqlx::query!(
+            r#"
+            INSERT INTO album_media (album_id, media_id)
+            SELECT $1, media_id FROM unnest($2::uuid[]) as media_id
+            ON CONFLICT (album_id, media_id) DO NOTHING
+            "#,
+            album_id,
+            media_ids
+        )
+        .execute(&self.pool)
+        .await
+        .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        Ok(())
+    }
+}

libertas_infra/src/repositories/media_repository.rs

@@ -0,0 +1,93 @@
+use async_trait::async_trait;
+use libertas_core::{
+    error::{CoreError, CoreResult},
+    models::Media,
+    repositories::MediaRepository,
+};
+use sqlx::PgPool;
+use uuid::Uuid;
+
+#[derive(Clone)]
+pub struct PostgresMediaRepository {
+    pool: PgPool,
+}
+
+impl PostgresMediaRepository {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait]
+impl MediaRepository for PostgresMediaRepository {
+    async fn create(&self, media: &Media) -> CoreResult<()> {
+        sqlx::query!(
+            r#"
+            INSERT INTO media (id, owner_id, storage_path, original_filename, mime_type, hash, created_at, width, height)
+            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+            "#,
+            media.id,
+            media.owner_id,
+            media.storage_path,
+            media.original_filename,
+            media.mime_type,
+            media.hash,
+            media.created_at,
+            media.width,
+            media.height
+        )
+        .execute(&self.pool)
+        .await
+        .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        Ok(())
+    }
+
+    async fn find_by_hash(&self, hash: &str) -> CoreResult<Option<Media>> {
+        sqlx::query_as!(
+            Media,
+            r#"
+            SELECT id, owner_id, storage_path, original_filename, mime_type, hash, created_at, 
+                   extracted_location, width, height
+            FROM media 
+            WHERE hash = $1
+            "#,
+            hash
+        )
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(|e| CoreError::Database(e.to_string()))
+    }
+
+    async fn find_by_id(&self, id: Uuid) -> CoreResult<Option<Media>> {
+        sqlx::query_as!(
+            Media,
+            r#"
+            SELECT id, owner_id, storage_path, original_filename, mime_type, hash, created_at, 
+                   extracted_location, width, height
+            FROM media 
+            WHERE id = $1
+            "#,
+            id
+        )
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(|e| CoreError::Database(e.to_string()))
+    }
+
+    async fn list_by_user(&self, user_id: Uuid) -> CoreResult<Vec<Media>> {
+        sqlx::query_as!(
+            Media,
+            r#"
+            SELECT id, owner_id, storage_path, original_filename, mime_type, hash, created_at, 
+                   extracted_location, width, height
+            FROM media 
+            WHERE owner_id = $1
+            "#,
+            user_id
+        )
+        .fetch_all(&self.pool)
+        .await
+        .map_err(|e| CoreError::Database(e.to_string()))
+    }
+}

libertas_infra/src/repositories/mod.rs

@@ -0,0 +1,3 @@
+pub mod album_repository;
+pub mod media_repository;
+pub mod user_repository;

libertas_infra/src/repositories/user_repository.rs

@@ -0,0 +1,96 @@
+use async_trait::async_trait;
+use libertas_core::{
+    error::{CoreError, CoreResult},
+    models::User,
+    repositories::UserRepository,
+};
+use sqlx::{PgPool, SqlitePool, types::Uuid};
+
+#[derive(Clone)]
+pub struct PostgresUserRepository {
+    pool: PgPool,
+}
+
+impl PostgresUserRepository {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+}
+
+#[derive(Clone)]
+pub struct SqliteUserRepository {
+    _pool: SqlitePool,
+}
+
+impl SqliteUserRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { _pool: pool }
+    }
+}
+
+#[async_trait]
+impl UserRepository for PostgresUserRepository {
+    async fn create(&self, user: User) -> CoreResult<()> {
+        sqlx::query!(
+            r#"
+            INSERT INTO users (id, username, email, hashed_password, created_at, updated_at)
+            VALUES ($1, $2, $3, $4, $5, $6)
+            "#,
+            user.id,
+            user.username,
+            user.email,
+            user.hashed_password,
+            user.created_at,
+            user.updated_at
+        )
+        .execute(&self.pool)
+        .await
+        .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        Ok(())
+    }
+
+    async fn find_by_email(&self, email: &str) -> CoreResult<Option<User>> {
+        sqlx::query_as!(User, "SELECT * FROM users WHERE email = $1", email)
+            .fetch_optional(&self.pool)
+            .await
+            .map_err(|e| CoreError::Database(e.to_string()))
+    }
+
+    async fn find_by_username(&self, username: &str) -> CoreResult<Option<User>> {
+        sqlx::query_as!(User, "SELECT * FROM users WHERE username = $1", username)
+            .fetch_optional(&self.pool)
+            .await
+            .map_err(|e| CoreError::Database(e.to_string()))
+    }
+
+    async fn find_by_id(&self, id: Uuid) -> CoreResult<Option<User>> {
+        sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", id)
+            .fetch_optional(&self.pool)
+            .await
+            .map_err(|e| CoreError::Database(e.to_string()))
+    }
+}
+
+#[async_trait]
+impl UserRepository for SqliteUserRepository {
+    async fn create(&self, _user: User) -> CoreResult<()> {
+        println!("SQLITE REPO: Creating user");
+        Ok(())
+    }
+
+    async fn find_by_email(&self, _email: &str) -> CoreResult<Option<User>> {
+        println!("SQLITE REPO: Finding user by email");
+        Ok(None)
+    }
+
+    async fn find_by_username(&self, _username: &str) -> CoreResult<Option<User>> {
+        println!("SQLITE REPO: Finding user by username");
+        Ok(None)
+    }
+
+    async fn find_by_id(&self, _id: Uuid) -> CoreResult<Option<User>> {
+        println!("SQLITE REPO: Finding user by id");
+        Ok(None)
+    }
+}