From 22857cf0564047eabf3099e335fb318b53c0e280 Mon Sep 17 00:00:00 2001 From: Gabriel Kaszewski Date: Mon, 3 Nov 2025 03:24:55 +0100 Subject: [PATCH] feat: enhance database configuration and media handling with PostgreSQL integration and storage quota management --- Cargo.lock | 2 + compose.yml | 14 +++ libertas_api/src/config.rs | 2 +- libertas_api/src/services/media_service.rs | 22 +++-- libertas_core/Cargo.toml | 2 +- libertas_infra/Cargo.toml | 2 + libertas_infra/src/db_models.rs | 64 +++++++++++++ libertas_infra/src/lib.rs | 2 + libertas_infra/src/mappers.rs | 96 +++++++++++++++++++ .../src/repositories/album_repository.rs | 17 ++-- .../repositories/album_share_repository.rs | 19 ++-- .../src/repositories/media_repository.rs | 26 +++-- .../src/repositories/user_repository.rs | 76 +++++++-------- libertas_worker/src/config.rs | 3 +- 14 files changed, 271 insertions(+), 76 deletions(-) create mode 100644 libertas_infra/src/db_models.rs create mode 100644 libertas_infra/src/mappers.rs diff --git a/Cargo.lock b/Cargo.lock index d05d3ad..278065d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1231,7 +1231,9 @@ name = "libertas_infra" version = "0.1.0" dependencies = [ "async-trait", + "chrono", "libertas_core", + "serde", "sqlx", "uuid", ] diff --git a/compose.yml b/compose.yml index 76b105a..805501d 100644 --- a/compose.yml +++ b/compose.yml @@ -7,3 +7,17 @@ services: - "6222:6222" - "8222:8222" restart: unless-stopped + db: + image: postgres:17 + container_name: libertas_db + environment: + POSTGRES_USER: libertas + POSTGRES_PASSWORD: libertas_password + POSTGRES_DB: libertas_db + ports: + - "5436:5432" + volumes: + - libertas_db_data:/var/lib/postgresql/data + restart: unless-stopped +volumes: + libertas_db_data: diff --git a/libertas_api/src/config.rs b/libertas_api/src/config.rs index 16de754..0236691 100644 --- a/libertas_api/src/config.rs +++ b/libertas_api/src/config.rs @@ -7,7 +7,7 @@ pub fn load_config() -> CoreResult { Ok(Config { database: DatabaseConfig { db_type: DatabaseType::Postgres, - url: "postgres://postgres:postgres@localhost:5432/libertas_db".to_string(), + url: "postgres://libertas:libertas_password@localhost:5436/libertas_db".to_string(), }, server_address: "127.0.0.1:8080".to_string(), jwt_secret: "super_secret_jwt_key".to_string(), diff --git a/libertas_api/src/services/media_service.rs b/libertas_api/src/services/media_service.rs index 825fbdb..ea30f05 100644 --- a/libertas_api/src/services/media_service.rs +++ b/libertas_api/src/services/media_service.rs @@ -48,13 +48,17 @@ impl MediaService for MediaServiceImpl { async fn upload_media(&self, mut data: UploadMediaData<'_>) -> CoreResult { let (file_bytes, hash, file_size) = self.hash_and_buffer_stream(&mut data).await?; - self.check_upload_prerequisites(data.owner_id, file_size, &hash) + let owner_id = data.owner_id; + let filename = data.filename; + let mime_type = data.mime_type; + + self.check_upload_prerequisites(owner_id, file_size, &hash) .await?; - let storage_path = self.persist_media_file(&file_bytes, &data.filename).await?; + let storage_path = self.persist_media_file(&file_bytes, &filename).await?; let media = self - .persist_media_metadata(&data, storage_path, hash, file_size) + .persist_media_metadata(owner_id, filename, mime_type, storage_path, hash, file_size) .await?; self.publish_new_media_job(media.id).await?; @@ -237,17 +241,19 @@ impl MediaServiceImpl { async fn persist_media_metadata( &self, - data: &UploadMediaData<'_>, + owner_id: Uuid, + filename: String, + mime_type: String, storage_path: String, hash: String, file_size: i64, ) -> CoreResult { let media_model = Media { id: Uuid::new_v4(), - owner_id: data.owner_id, + owner_id, storage_path, - original_filename: data.filename.clone(), - mime_type: data.mime_type.clone(), + original_filename: filename, + mime_type, hash, created_at: chrono::Utc::now(), extracted_location: None, @@ -257,7 +263,7 @@ impl MediaServiceImpl { self.repo.create(&media_model).await?; self.user_repo - .update_storage_used(data.owner_id, file_size) + .update_storage_used(owner_id, file_size) .await?; Ok(media_model) diff --git a/libertas_core/Cargo.toml b/libertas_core/Cargo.toml index eec4097..7899d30 100644 --- a/libertas_core/Cargo.toml +++ b/libertas_core/Cargo.toml @@ -10,7 +10,7 @@ bytes = "1.10.1" chrono = "0.4.42" futures = "0.3.31" thiserror = "2.0.17" -uuid = "1.18.1" +uuid = {version = "1.18.1", features = ["v4", "serde"] } sqlx = { version = "0.8.6", features = [ "runtime-tokio", "postgres", diff --git a/libertas_infra/Cargo.toml b/libertas_infra/Cargo.toml index a11f87d..65f9c3a 100644 --- a/libertas_infra/Cargo.toml +++ b/libertas_infra/Cargo.toml @@ -14,3 +14,5 @@ sqlx = { version = "0.8.6", features = [ ] } async-trait = "0.1.89" uuid = { version = "1.18.1", features = ["v4"] } +chrono = "0.4.42" +serde = { version = "1.0.228", features = ["derive"] } diff --git a/libertas_infra/src/db_models.rs b/libertas_infra/src/db_models.rs new file mode 100644 index 0000000..a24dfdd --- /dev/null +++ b/libertas_infra/src/db_models.rs @@ -0,0 +1,64 @@ +use chrono::Utc; +use serde::Deserialize; +use uuid::Uuid; + +#[derive(Debug, Clone, PartialEq, Eq, sqlx::Type)] +#[sqlx(rename_all = "lowercase")] +#[sqlx(type_name = "TEXT")] +pub enum PostgresRole { + User, + Admin, +} + + +#[derive(sqlx::FromRow)] +pub struct PostgresUser { + pub id: Uuid, + pub username: String, + pub email: String, + pub hashed_password: String, + pub created_at: chrono::DateTime, + pub updated_at: chrono::DateTime, + pub role: String, + pub storage_quota: i64, + pub storage_used: i64, +} + +#[derive(sqlx::FromRow)] +pub struct PostgresAlbum { + pub id: uuid::Uuid, + pub owner_id: uuid::Uuid, + pub name: String, + pub description: Option, + pub is_public: bool, + pub created_at: chrono::DateTime, + pub updated_at: chrono::DateTime, +} + +#[derive(sqlx::FromRow)] +pub struct PostgresMedia { + pub id: uuid::Uuid, + pub owner_id: uuid::Uuid, + pub storage_path: String, + pub original_filename: String, + pub mime_type: String, + pub hash: String, + pub created_at: chrono::DateTime, + pub extracted_location: Option, + pub width: Option, + pub height: Option, +} + +#[derive(Debug, Clone, Copy, sqlx::Type, PartialEq, Eq, Deserialize)] +#[sqlx(rename_all = "lowercase")] +#[sqlx(type_name = "album_permission")] +pub enum PostgresAlbumPermission { + View, + Contribute, +} + +pub struct PostgresAlbumShare { + pub album_id: uuid::Uuid, + pub user_id: uuid::Uuid, + pub permission: PostgresAlbumPermission, +} \ No newline at end of file diff --git a/libertas_infra/src/lib.rs b/libertas_infra/src/lib.rs index 12c05bb..1be526d 100644 --- a/libertas_infra/src/lib.rs +++ b/libertas_infra/src/lib.rs @@ -1,2 +1,4 @@ pub mod factory; pub mod repositories; +pub mod db_models; +pub mod mappers; \ No newline at end of file diff --git a/libertas_infra/src/mappers.rs b/libertas_infra/src/mappers.rs new file mode 100644 index 0000000..39d72d6 --- /dev/null +++ b/libertas_infra/src/mappers.rs @@ -0,0 +1,96 @@ +use libertas_core::models::{Album, AlbumPermission, AlbumShare, Media, Role, User}; + +use crate::db_models::{PostgresAlbum, PostgresAlbumPermission, PostgresAlbumShare, PostgresMedia, PostgresRole, PostgresUser}; + +impl From for Role { + fn from(pg_role: PostgresRole) -> Self { + match pg_role { + PostgresRole::User => Role::User, + PostgresRole::Admin => Role::Admin, + } + } +} + +impl From for PostgresRole { + fn from(role: Role) -> Self { + match role { + Role::User => PostgresRole::User, + Role::Admin => PostgresRole::Admin, + } + } +} + +impl From for User { + fn from(pg_user: PostgresUser) -> Self { + User { + id: pg_user.id, + username: pg_user.username, + email: pg_user.email, + hashed_password: pg_user.hashed_password, + created_at: pg_user.created_at, + updated_at: pg_user.updated_at, + role: Role::from(pg_user.role.as_str()), + storage_quota: pg_user.storage_quota, + storage_used: pg_user.storage_used, + } + } +} + +impl From for Album { + fn from(pg_album: PostgresAlbum) -> Self { + Album { + id: pg_album.id, + owner_id: pg_album.owner_id, + name: pg_album.name, + description: pg_album.description, + is_public: pg_album.is_public, + created_at: pg_album.created_at, + updated_at: pg_album.updated_at, + } + } +} + +impl From for Media { + fn from(pg_media: PostgresMedia) -> Self { + Media { + id: pg_media.id, + owner_id: pg_media.owner_id, + storage_path: pg_media.storage_path, + original_filename: pg_media.original_filename, + mime_type: pg_media.mime_type, + hash: pg_media.hash, + created_at: pg_media.created_at, + extracted_location: pg_media.extracted_location, + width: pg_media.width, + height: pg_media.height, + } + } +} + +impl From for AlbumPermission { + fn from(pg_permission: PostgresAlbumPermission) -> Self { + match pg_permission { + PostgresAlbumPermission::View => AlbumPermission::View, + PostgresAlbumPermission::Contribute => AlbumPermission::Contribute, + } + } +} + +impl From for PostgresAlbumPermission { + fn from(permission: AlbumPermission) -> Self { + match permission { + AlbumPermission::View => PostgresAlbumPermission::View, + AlbumPermission::Contribute => PostgresAlbumPermission::Contribute, + } + } +} + +impl From for AlbumShare { + fn from(pg_share: PostgresAlbumShare) -> Self { + AlbumShare { + album_id: pg_share.album_id, + user_id: pg_share.user_id, + permission: AlbumPermission::from(pg_share.permission), + } + } +} \ No newline at end of file diff --git a/libertas_infra/src/repositories/album_repository.rs b/libertas_infra/src/repositories/album_repository.rs index da3c6fc..7816002 100644 --- a/libertas_infra/src/repositories/album_repository.rs +++ b/libertas_infra/src/repositories/album_repository.rs @@ -7,6 +7,8 @@ use libertas_core::{ use sqlx::PgPool; use uuid::Uuid; +use crate::db_models::PostgresAlbum; + #[derive(Clone)] pub struct PostgresAlbumRepository { pool: PgPool, @@ -42,8 +44,8 @@ impl AlbumRepository for PostgresAlbumRepository { } async fn find_by_id(&self, id: Uuid) -> CoreResult> { - sqlx::query_as!( - Album, + let pg_album = sqlx::query_as!( + PostgresAlbum, r#" SELECT id, owner_id, name, description, is_public, created_at, updated_at FROM albums @@ -53,12 +55,13 @@ impl AlbumRepository for PostgresAlbumRepository { ) .fetch_optional(&self.pool) .await - .map_err(|e| CoreError::Database(e.to_string())) + .map_err(|e| CoreError::Database(e.to_string()))?; + Ok(pg_album.map(|a| a.into())) } async fn list_by_user(&self, user_id: Uuid) -> CoreResult> { - sqlx::query_as!( - Album, + let pg_albums = sqlx::query_as!( + PostgresAlbum, r#" SELECT id, owner_id, name, description, is_public, created_at, updated_at FROM albums @@ -68,7 +71,9 @@ impl AlbumRepository for PostgresAlbumRepository { ) .fetch_all(&self.pool) .await - .map_err(|e| CoreError::Database(e.to_string())) + .map_err(|e| CoreError::Database(e.to_string()))?; + + Ok(pg_albums.into_iter().map(|a| a.into()).collect()) } async fn add_media_to_album(&self, album_id: Uuid, media_ids: &[Uuid]) -> CoreResult<()> { diff --git a/libertas_infra/src/repositories/album_share_repository.rs b/libertas_infra/src/repositories/album_share_repository.rs index 5eb7511..d1c51c3 100644 --- a/libertas_infra/src/repositories/album_share_repository.rs +++ b/libertas_infra/src/repositories/album_share_repository.rs @@ -1,11 +1,10 @@ use async_trait::async_trait; use libertas_core::{ - error::{CoreError, CoreResult}, - models::AlbumPermission, - repositories::AlbumShareRepository, + error::{CoreError, CoreResult}, models::AlbumPermission, repositories::AlbumShareRepository }; use sqlx::PgPool; use uuid::Uuid; +use crate::db_models::PostgresAlbumPermission; #[derive(Clone)] pub struct PostgresAlbumShareRepository { @@ -35,7 +34,7 @@ impl AlbumShareRepository for PostgresAlbumShareRepository { "#, album_id, user_id, - permission.as_str() as "album_permission" + PostgresAlbumPermission::from(permission) as PostgresAlbumPermission, ) .execute(&self.pool) .await @@ -49,9 +48,12 @@ impl AlbumShareRepository for PostgresAlbumShareRepository { album_id: Uuid, user_id: Uuid, ) -> CoreResult> { - let row = sqlx::query!( - // --- FIX 2: CAST the enum to TEXT in the SQL --- - "SELECT permission::TEXT as permission FROM album_shares WHERE album_id = $1 AND user_id = $2", + let result = sqlx::query!( + r#" + SELECT permission as "permission: PostgresAlbumPermission" + FROM album_shares + WHERE album_id = $1 AND user_id = $2 + "#, album_id, user_id ) @@ -59,8 +61,7 @@ impl AlbumShareRepository for PostgresAlbumShareRepository { .await .map_err(|e| CoreError::Database(e.to_string()))?; - // This now works because r.permission is a String - Ok(row.map(|r| AlbumPermission::from(r.permission.as_str()))) + Ok(result.map(|row| row.permission.into())) } async fn is_media_in_shared_album(&self, media_id: Uuid, user_id: Uuid) -> CoreResult { diff --git a/libertas_infra/src/repositories/media_repository.rs b/libertas_infra/src/repositories/media_repository.rs index 1ed7710..a9d3e05 100644 --- a/libertas_infra/src/repositories/media_repository.rs +++ b/libertas_infra/src/repositories/media_repository.rs @@ -7,6 +7,8 @@ use libertas_core::{ use sqlx::PgPool; use uuid::Uuid; +use crate::db_models::PostgresMedia; + #[derive(Clone)] pub struct PostgresMediaRepository { pool: PgPool, @@ -44,8 +46,8 @@ impl MediaRepository for PostgresMediaRepository { } async fn find_by_hash(&self, hash: &str) -> CoreResult> { - sqlx::query_as!( - Media, + let pg_media = sqlx::query_as!( + PostgresMedia, r#" SELECT id, owner_id, storage_path, original_filename, mime_type, hash, created_at, extracted_location, width, height @@ -56,12 +58,14 @@ impl MediaRepository for PostgresMediaRepository { ) .fetch_optional(&self.pool) .await - .map_err(|e| CoreError::Database(e.to_string())) + .map_err(|e| CoreError::Database(e.to_string()))?; + + Ok(pg_media.map(|m| m.into())) } async fn find_by_id(&self, id: Uuid) -> CoreResult> { - sqlx::query_as!( - Media, + let pg_media = sqlx::query_as!( + PostgresMedia, r#" SELECT id, owner_id, storage_path, original_filename, mime_type, hash, created_at, extracted_location, width, height @@ -72,12 +76,14 @@ impl MediaRepository for PostgresMediaRepository { ) .fetch_optional(&self.pool) .await - .map_err(|e| CoreError::Database(e.to_string())) + .map_err(|e| CoreError::Database(e.to_string()))?; + + Ok(pg_media.map(|m| m.into())) } async fn list_by_user(&self, user_id: Uuid) -> CoreResult> { - sqlx::query_as!( - Media, + let pg_media = sqlx::query_as!( + PostgresMedia, r#" SELECT id, owner_id, storage_path, original_filename, mime_type, hash, created_at, extracted_location, width, height @@ -88,7 +94,9 @@ impl MediaRepository for PostgresMediaRepository { ) .fetch_all(&self.pool) .await - .map_err(|e| CoreError::Database(e.to_string())) + .map_err(|e| CoreError::Database(e.to_string()))?; + + Ok(pg_media.into_iter().map(|m| m.into()).collect()) } async fn update_metadata( diff --git a/libertas_infra/src/repositories/user_repository.rs b/libertas_infra/src/repositories/user_repository.rs index 9372640..069ddf4 100644 --- a/libertas_infra/src/repositories/user_repository.rs +++ b/libertas_infra/src/repositories/user_repository.rs @@ -1,11 +1,13 @@ use async_trait::async_trait; use libertas_core::{ error::{CoreError, CoreResult}, - models::{Role, User}, + models::User, repositories::UserRepository, }; use sqlx::{PgPool, SqlitePool, types::Uuid}; +use crate::db_models::PostgresUser; + #[derive(Clone)] pub struct PostgresUserRepository { pool: PgPool, @@ -54,69 +56,61 @@ impl UserRepository for PostgresUserRepository { } async fn find_by_email(&self, email: &str) -> CoreResult> { - let row = sqlx::query!( - r#"SELECT id, username, email, hashed_password, created_at, updated_at, role, storage_quota, storage_used FROM users WHERE email = $1"#, + let pg_user = sqlx::query_as!( + PostgresUser, + r#" + SELECT + id, username, email, hashed_password, created_at, updated_at, + role, + storage_quota, storage_used + FROM users + WHERE email = $1 + "#, email ) .fetch_optional(&self.pool) .await .map_err(|e| CoreError::Database(e.to_string()))?; - Ok(row.map(|r| User { - id: r.id, - username: r.username, - email: r.email, - hashed_password: r.hashed_password, - created_at: r.created_at, - updated_at: r.updated_at, - role: Role::from(r.role.as_str()), - storage_quota: r.storage_quota, - storage_used: r.storage_used, - })) + Ok(pg_user.map(|u| u.into())) } async fn find_by_username(&self, username: &str) -> CoreResult> { - let row = sqlx::query!( - r#"SELECT id, username, email, hashed_password, created_at, updated_at, role, storage_quota, storage_used FROM users WHERE username = $1"#, + let pg_user = sqlx::query_as!( + PostgresUser, + r#" + SELECT + id, username, email, hashed_password, created_at, updated_at, + role, storage_quota, storage_used + FROM users + WHERE username = $1 + "#, username ) .fetch_optional(&self.pool) .await .map_err(|e| CoreError::Database(e.to_string()))?; - Ok(row.map(|r| User { - id: r.id, - username: r.username, - email: r.email, - hashed_password: r.hashed_password, - created_at: r.created_at, - updated_at: r.updated_at, - role: Role::from(r.role.as_str()), - storage_quota: r.storage_quota, - storage_used: r.storage_used, - })) + Ok(pg_user.map(|u| u.into())) } async fn find_by_id(&self, id: Uuid) -> CoreResult> { - let row = sqlx::query!( - r#"SELECT id, username, email, hashed_password, created_at, updated_at, role, storage_quota, storage_used FROM users WHERE id = $1"#, + let pg_user = sqlx::query_as!( + PostgresUser, + r#" + SELECT + id, username, email, hashed_password, created_at, updated_at, + role, + storage_quota, storage_used + FROM users + WHERE id = $1 + "#, id ) .fetch_optional(&self.pool) .await .map_err(|e| CoreError::Database(e.to_string()))?; - - Ok(row.map(|r| User { - id: r.id, - username: r.username, - email: r.email, - hashed_password: r.hashed_password, - created_at: r.created_at, - updated_at: r.updated_at, - role: Role::from(r.role.as_str()), - storage_quota: r.storage_quota, - storage_used: r.storage_used, - })) + Ok(pg_user.map(|u| u.into())) } async fn update_storage_used(&self, user_id: Uuid, bytes: i64) -> CoreResult<()> { diff --git a/libertas_worker/src/config.rs b/libertas_worker/src/config.rs index a239a55..0236691 100644 --- a/libertas_worker/src/config.rs +++ b/libertas_worker/src/config.rs @@ -7,12 +7,13 @@ pub fn load_config() -> CoreResult { Ok(Config { database: DatabaseConfig { db_type: DatabaseType::Postgres, - url: "postgres://postgres:postgres@localhost:5432/libertas_db".to_string(), + url: "postgres://libertas:libertas_password@localhost:5436/libertas_db".to_string(), }, server_address: "127.0.0.1:8080".to_string(), jwt_secret: "super_secret_jwt_key".to_string(), media_library_path: "media_library".to_string(), broker_url: "nats://localhost:4222".to_string(), max_upload_size_mb: Some(100), + default_storage_quota_gb: Some(10), }) }