feat: implement media listing with sorting and filtering options

libertas_api/src/config.rs

@@ -15,5 +15,10 @@ pub fn load_config() -> CoreResult<Config> {
         broker_url: "nats://localhost:4222".to_string(),
         max_upload_size_mb: Some(100),
         default_storage_quota_gb: Some(10),
+        allowed_sort_columns: Some(vec![
+            "date_taken".to_string(),
+            "created_at".to_string(),
+            "original_filename".to_string(),
+        ]),
     })
 }

libertas_api/src/extractors/mod.rs

@@ -0,0 +1 @@
+pub mod query_options;

libertas_api/src/extractors/query_options.rs

@@ -0,0 +1,42 @@
+use axum::{extract::{FromRequestParts, Query}, http::request::Parts};
+use libertas_core::{error::CoreError, schema::{FilterParams, ListMediaOptions, SortOrder, SortParams}};
+
+use crate::{error::ApiError, schema::ListMediaParams, state::AppState};
+
+pub struct ApiListMediaOptions(pub ListMediaOptions);
+
+impl From<ListMediaParams> for ListMediaOptions {
+    fn from(params: ListMediaParams) -> Self {
+        let sort = params.sort_by.map(|field| {
+            let order = match params.order.as_deref() {
+                Some("asc") => SortOrder::Asc,
+                _ => SortOrder::Desc,
+            };
+            SortParams {
+                sort_by: field,
+                sort_order: order,
+            }
+        });
+
+        let filter = Some(FilterParams {
+            // e.g., mime_type: params.mime_type
+        });
+
+        ListMediaOptions { sort, filter }
+    }
+}
+
+impl FromRequestParts<AppState> for ApiListMediaOptions {
+    type Rejection = ApiError;
+
+    async fn from_request_parts(
+        parts: &mut Parts,
+        state: &AppState,
+    ) -> Result<Self, Self::Rejection> {
+        let Query(params) = Query::<ListMediaParams>::from_request_parts(parts, state)
+            .await
+            .map_err(|e| ApiError::from(CoreError::Validation(e.to_string())))?;
+
+        Ok(ApiListMediaOptions(params.into()))
+    }
+}

libertas_api/src/factory.rs

@@ -27,7 +27,7 @@ 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 media_repo = build_media_repository(&config, db_pool.clone()).await?;
     let album_repo = build_album_repository(&config.database, db_pool.clone()).await?;
     let album_share_repo = build_album_share_repository(&config.database, db_pool.clone()).await?;
 

libertas_api/src/handlers/media_handlers.rs

@@ -7,23 +7,14 @@ use axum::{
 };
 use futures::TryStreamExt;
 use libertas_core::{error::CoreError, models::Media, schema::UploadMediaData};
-use serde::Serialize;
 use std::{io, path::PathBuf};
 
 use tower::ServiceExt;
 use tower_http::services::ServeFile;
 use uuid::Uuid;
 
-use crate::{error::ApiError, middleware::auth::UserId, state::AppState};
+use crate::{error::ApiError, extractors::query_options::ApiListMediaOptions, middleware::auth::UserId, schema::MediaResponse, state::AppState};
 
-#[derive(Serialize)]
-pub struct MediaResponse {
-    id: uuid::Uuid,
-    storage_path: String,
-    original_filename: String,
-    mime_type: String,
-    hash: String,
-}
 
 impl From<Media> for MediaResponse {
     fn from(media: Media) -> Self {
@@ -39,7 +30,7 @@ impl From<Media> for MediaResponse {
 
 pub fn media_routes(max_upload_size: usize) -> Router<AppState> {
     Router::new()
-        .route("/", post(upload_media))
+        .route("/", post(upload_media).get(list_user_media))
         .route("/{id}", get(get_media_details).delete(delete_media))
         .route("/{id}/file", get(get_media_file))
         .layer(DefaultBodyLimit::max(max_upload_size))
@@ -123,3 +114,17 @@ async fn delete_media(
     state.media_service.delete_media(id, user_id).await?;
     Ok(StatusCode::NO_CONTENT)
 }
+
+async fn list_user_media(
+    State(state): State<AppState>,
+    UserId(user_id): UserId,
+    ApiListMediaOptions(options): ApiListMediaOptions,
+) -> Result<Json<Vec<MediaResponse>>, ApiError> {    
+    let media_list = state
+        .media_service
+        .list_user_media(user_id, options)
+        .await?;
+
+    let response = media_list.into_iter().map(MediaResponse::from).collect();
+    Ok(Json(response))
+}

libertas_api/src/main.rs

@@ -11,6 +11,8 @@ pub mod routes;
 pub mod security;
 pub mod services;
 pub mod state;
+pub mod extractors;
+pub mod schema;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {

libertas_api/src/schema.rs

@@ -0,0 +1,18 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize)]
+pub struct MediaResponse {
+    pub id: uuid::Uuid,
+    pub storage_path: String,
+    pub original_filename: String,
+    pub mime_type: String,
+    pub hash: String,
+}
+
+#[derive(Deserialize)]
+pub struct ListMediaParams {
+    pub sort_by: Option<String>,
+    pub order: Option<String>,
+    // You can add future filters here, e.g.:
+    // pub mime_type: Option<String>,
+}

libertas_api/src/services/media_service.rs

@@ -9,7 +9,7 @@ use libertas_core::{
     error::{CoreError, CoreResult},
     models::Media,
     repositories::{AlbumShareRepository, MediaRepository, UserRepository},
-    schema::UploadMediaData,
+    schema::{ListMediaOptions, UploadMediaData},
     services::MediaService,
 };
 use serde_json::json;
@@ -95,8 +95,8 @@ impl MediaService for MediaServiceImpl {
         Err(CoreError::Auth("Access denied".to_string()))
     }
 
-    async fn list_user_media(&self, user_id: Uuid) -> CoreResult<Vec<Media>> {
+    async fn list_user_media(&self, user_id: Uuid, options: ListMediaOptions) -> CoreResult<Vec<Media>> {
-        self.repo.list_by_user(user_id).await
+        self.repo.list_by_user(user_id, &options).await
     }
 
     async fn get_media_filepath(&self, id: Uuid, user_id: Uuid) -> CoreResult<String> {

libertas_core/src/config.rs

@@ -21,4 +21,5 @@ pub struct Config {
     pub broker_url: String,
     pub max_upload_size_mb: Option<u32>,
     pub default_storage_quota_gb: Option<u64>,
+    pub allowed_sort_columns: Option<Vec<String>>,
 }

libertas_core/src/repositories.rs

@@ -3,7 +3,7 @@ use uuid::Uuid;
 
 use crate::{
     error::CoreResult,
-    models::{Album, AlbumPermission, Media, User},
+    models::{Album, AlbumPermission, Media, User}, schema::ListMediaOptions,
 };
 
 #[async_trait]
@@ -11,7 +11,7 @@ pub trait MediaRepository: Send + Sync {
     async fn find_by_hash(&self, hash: &str) -> CoreResult<Option<Media>>;
     async fn create(&self, media: &Media) -> CoreResult<()>;
     async fn find_by_id(&self, id: Uuid) -> CoreResult<Option<Media>>;
-    async fn list_by_user(&self, user_id: Uuid) -> CoreResult<Vec<Media>>;
+    async fn list_by_user(&self, user_id: Uuid, options: &ListMediaOptions) -> CoreResult<Vec<Media>>;
     async fn update_metadata(
         &self,
         id: Uuid,

libertas_core/src/schema.rs

@@ -52,3 +52,29 @@ pub struct UserResponse {
     pub username: String,
     pub email: String,
 }
+
+#[derive(Debug, Clone)]
+pub enum SortOrder {
+    Asc,
+    Desc,
+}
+
+#[derive(Debug, Clone)]
+pub struct SortParams {
+    pub sort_by: String,
+    pub sort_order: SortOrder,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct FilterParams {
+    // In the future, you can add fields like:
+    // pub mime_type: Option<String>,
+    // pub date_range: Option<(chrono::DateTime<chrono::Utc>, chrono::DateTime<chrono::Utc>)>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ListMediaOptions {
+    pub sort: Option<SortParams>,
+    pub filter: Option<FilterParams>,
+    // pub pagination: Option<PaginationParams>,
+}

libertas_core/src/services.rs

@@ -5,8 +5,7 @@ use crate::{
     error::CoreResult,
     models::{Album, Media, User},
     schema::{
-        AddMediaToAlbumData, CreateAlbumData, CreateUserData, LoginUserData, ShareAlbumData,
+        AddMediaToAlbumData, CreateAlbumData, CreateUserData, ListMediaOptions, LoginUserData, ShareAlbumData, UpdateAlbumData, UploadMediaData
-        UpdateAlbumData, UploadMediaData,
     },
 };
 
@@ -14,7 +13,7 @@ use crate::{
 pub trait MediaService: Send + Sync {
     async fn upload_media(&self, data: UploadMediaData<'_>) -> CoreResult<Media>;
     async fn get_media_details(&self, id: Uuid, user_id: Uuid) -> CoreResult<Media>;
-    async fn list_user_media(&self, user_id: Uuid) -> CoreResult<Vec<Media>>;
+    async fn list_user_media(&self, user_id: Uuid, options: ListMediaOptions) -> CoreResult<Vec<Media>>;
     async fn get_media_filepath(&self, id: Uuid, user_id: Uuid) -> CoreResult<String>;
     async fn delete_media(&self, id: Uuid, user_id: Uuid) -> CoreResult<()>;
 }

libertas_infra/src/factory.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use libertas_core::{
-    config::{DatabaseConfig, DatabaseType},
+    config::{Config, DatabaseConfig, DatabaseType},
     error::{CoreError, CoreResult},
     repositories::UserRepository,
 };
@@ -47,12 +47,12 @@ pub async fn build_user_repository(
 }
 
 pub async fn build_media_repository(
-    _db_config: &DatabaseConfig,
+    config: &Config,
     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),
+            crate::repositories::media_repository::PostgresMediaRepository::new(pg_pool, config),
         )),
         DatabasePool::Sqlite(_sqlite_pool) => Err(CoreError::Database(
             "Sqlite media repository not implemented".to_string(),

libertas_infra/src/lib.rs

@@ -2,3 +2,4 @@ pub mod factory;
 pub mod repositories;
 pub mod db_models;
 pub mod mappers;
+pub mod query_builder;

libertas_infra/src/query_builder.rs

@@ -0,0 +1,80 @@
+use libertas_core::{error::{CoreError, CoreResult}, schema::{ListMediaOptions, SortOrder}};
+use sqlx::QueryBuilder as SqlxQueryBuilder;
+
+pub trait QueryBuilder<T> {
+    fn apply_options_to_query<'a>(
+        &self,
+        query: SqlxQueryBuilder<'a, sqlx::Postgres>,
+        options: &'a T,
+    ) -> CoreResult<SqlxQueryBuilder<'a, sqlx::Postgres>>;
+}
+
+pub struct MediaQueryBuilder {
+    allowed_sort_columns: Vec<String>,
+}
+
+impl MediaQueryBuilder {
+    pub fn new(allowed_sort_columns: Vec<String>) -> Self {
+        Self {
+            allowed_sort_columns,
+        }
+    }
+
+    fn validate_sort_column<'a>(&self, column: &'a str) -> CoreResult<&'a str> {
+        if self.allowed_sort_columns.contains(&column.to_string()) {
+            Ok(column)
+        } else {
+            Err(CoreError::Validation(format!(
+                "Sorting by '{}' is not supported",
+                column
+            )))
+        }
+    }
+}
+
+impl QueryBuilder<ListMediaOptions> for MediaQueryBuilder {
+    fn apply_options_to_query<'a>(
+        &self,
+        mut query: SqlxQueryBuilder<'a, sqlx::Postgres>,
+        options: &'a ListMediaOptions,
+    ) -> CoreResult<SqlxQueryBuilder<'a, sqlx::Postgres>> {
+        if let Some(filter) = &options.filter {
+            // In the future, you would add logic here:
+            // if let Some(mime) = &filter.mime_type {
+            //     query.push(" AND mime_type = ");
+            //     query.push_bind(mime);
+            // }
+        }
+
+        if let Some(sort) = &options.sort {
+            let column = self.validate_sort_column(&sort.sort_by)?;
+            
+            let direction = match sort.sort_order {
+                SortOrder::Asc => "ASC",
+                SortOrder::Desc => "DESC",
+            };
+
+            let nulls_order = if direction == "ASC" {
+                "NULLS LAST"
+            } else {
+                "NULLS FIRST"
+            };
+
+            let order_by_clause = format!("ORDER BY {} {} {}", column, direction, nulls_order);
+            query.push(order_by_clause);
+        
+        } else {
+            query.push("ORDER BY date_taken DESC NULLS FIRST");
+        }
+
+        // --- 3. Apply Pagination (Future-Proofing Stub) ---
+        // if let Some(pagination) = &options.pagination {
+        //     query.push(" LIMIT ");
+        //     query.push_bind(pagination.limit);
+        //     query.push(" OFFSET ");
+        //     query.push_bind(pagination.offset);
+        // }
+
+        Ok(query)
+    }
+}

libertas_infra/src/repositories/media_repository.rs

@@ -1,22 +1,28 @@
+use std::sync::Arc;
+
 use async_trait::async_trait;
 use libertas_core::{
-    error::{CoreError, CoreResult},
+    config::Config, error::{CoreError, CoreResult}, models::Media, repositories::MediaRepository, schema::ListMediaOptions
-    models::Media,
-    repositories::MediaRepository,
 };
 use sqlx::PgPool;
 use uuid::Uuid;
 
-use crate::db_models::PostgresMedia;
+use crate::{db_models::PostgresMedia, query_builder::{MediaQueryBuilder, QueryBuilder}};
 
 #[derive(Clone)]
 pub struct PostgresMediaRepository {
     pool: PgPool,
+    query_builder: Arc<MediaQueryBuilder>,
 }
 
 impl PostgresMediaRepository {
-    pub fn new(pool: PgPool) -> Self {
+    pub fn new(pool: PgPool, config: &Config) -> Self {
-        Self { pool }
+        let allowed_columns = config
+            .allowed_sort_columns
+            .clone()
+            .unwrap_or_else(|| vec!["created_at".to_string()]);
+
+        Self { pool, query_builder: Arc::new(MediaQueryBuilder::new(allowed_columns)) }
     }
 }
 
@@ -81,22 +87,30 @@ impl MediaRepository for PostgresMediaRepository {
         Ok(pg_media.map(|m| m.into()))
     }
 
-    async fn list_by_user(&self, user_id: Uuid) -> CoreResult<Vec<Media>> {
+    async fn list_by_user(&self, user_id: Uuid, options: &ListMediaOptions) -> CoreResult<Vec<Media>> {
-        let pg_media = sqlx::query_as!(
+        let mut query = sqlx::QueryBuilder::new(
-            PostgresMedia,
             r#"
             SELECT id, owner_id, storage_path, original_filename, mime_type, hash, created_at, 
                    extracted_location, width, height, date_taken
             FROM media 
-            WHERE owner_id = $1
+            WHERE owner_id = 
             "#,
-            user_id
+        );
-        )
+
+        query.push_bind(user_id);
+
+        query = self
+            .query_builder
+            .apply_options_to_query(query, options)?;
+
+        let pg_media = query
+        .build_query_as::<PostgresMedia>()
         .fetch_all(&self.pool)
         .await
         .map_err(|e| CoreError::Database(e.to_string()))?;
         
-        Ok(pg_media.into_iter().map(|m| m.into()).collect())
+        let media_list = pg_media.into_iter().map(|m| m.into()).collect();
+        Ok(media_list)
     }
 
     async fn update_metadata(

libertas_worker/src/config.rs

@@ -15,5 +15,10 @@ pub fn load_config() -> CoreResult<Config> {
         broker_url: "nats://localhost:4222".to_string(),
         max_upload_size_mb: Some(100),
         default_storage_quota_gb: Some(10),
+        allowed_sort_columns: Some(vec![
+            "date_taken".to_string(),
+            "created_at".to_string(),
+            "original_filename".to_string(),
+        ]),
     })
 }

libertas_worker/src/main.rs

@@ -34,7 +34,7 @@ async fn main() -> anyhow::Result<()> {
     let db_pool = build_database_pool(&config.database).await?;
     println!("Worker connected to database.");
 
-    let media_repo = build_media_repository(&config.database, db_pool.clone()).await?;
+    let media_repo = build_media_repository(&config, db_pool.clone()).await?;
     let album_repo = build_album_repository(&config.database, db_pool.clone()).await?;
     let user_repo = build_user_repository(&config.database, db_pool.clone()).await?;