feat: Implement pagination for user media retrieval and update related structures

libertas_infra/src/repositories/media_repository.rs

@@ -11,10 +11,7 @@ use libertas_core::{
 use sqlx::PgPool;
 use uuid::Uuid;
 
-use crate::{
-    db_models::PostgresMedia,
-    query_builder::{MediaQueryBuilder, QueryBuilder},
-};
+use crate::{db_models::PostgresMedia, query_builder::MediaQueryBuilder};
 
 #[derive(Clone)]
 pub struct PostgresMediaRepository {
@@ -106,28 +103,63 @@ impl MediaRepository for PostgresMediaRepository {
         &self,
         user_id: Uuid,
         options: &ListMediaOptions,
-    ) -> CoreResult<Vec<Media>> {
-        let mut query = sqlx::QueryBuilder::new(
-            r#"
-            SELECT media.id, media.owner_id, media.storage_path, media.original_filename, media.mime_type, media.hash, media.created_at, 
-                   media.thumbnail_path
-            FROM media 
-            WHERE media.owner_id = 
-            "#,
-        );
+    ) -> CoreResult<(Vec<Media>, i64)> {
+        let count_base_sql = "SELECT COUNT(DISTINCT media.id) as total FROM media";
+        let mut count_query = sqlx::QueryBuilder::new(count_base_sql);
+        count_query.push(" WHERE media.owner_id = ");
+        count_query.push_bind(user_id);
 
-        query.push_bind(user_id);
+        let (mut count_query, metadata_filter_count) = self
+            .query_builder
+            .apply_filters_to_query(count_query, options)?;
 
-        query = self.query_builder.apply_options_to_query(query, options)?;
+        if metadata_filter_count > 0 {
+            count_query.push(" GROUP BY media.id ");
+            count_query.push(" HAVING COUNT(DISTINCT mm.tag_name) = ");
+            count_query.push_bind(metadata_filter_count);
 
-        let pg_media = query
+            let mut final_count_query = sqlx::QueryBuilder::new("SELECT COUNT(*) as total FROM (");
+            final_count_query.push(count_query.into_sql());
+            final_count_query.push(") as subquery");
+            count_query = final_count_query;
+        }
+
+        let total_items_result = count_query
+            .build_query_scalar()
+            .fetch_one(&self.pool)
+            .await
+            .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        let data_base_sql = "SELECT media.id, media.owner_id, media.storage_path, media.original_filename, media.mime_type, media.hash, media.created_at, media.thumbnail_path FROM media";
+        let mut data_query = sqlx::QueryBuilder::new(data_base_sql);
+        data_query.push(" WHERE media.owner_id = ");
+        data_query.push_bind(user_id);
+
+        let (mut data_query, metadata_filter_count) = self
+            .query_builder
+            .apply_filters_to_query(data_query, options)?;
+
+        if metadata_filter_count > 0 {
+            data_query.push(" GROUP BY media.id ");
+            data_query.push(" HAVING COUNT(DISTINCT mm.tag_name) = ");
+            data_query.push_bind(metadata_filter_count);
+        }
+
+        data_query = self
+            .query_builder
+            .apply_sorting_to_query(data_query, options)?;
+        data_query = self
+            .query_builder
+            .apply_pagination_to_query(data_query, options)?;
+
+        let pg_media = data_query
             .build_query_as::<PostgresMedia>()
             .fetch_all(&self.pool)
             .await
             .map_err(|e| CoreError::Database(e.to_string()))?;
 
         let media_list = pg_media.into_iter().map(|m| m.into()).collect();
-        Ok(media_list)
+        Ok((media_list, total_items_result))
     }
 
     async fn update_thumbnail_path(&self, id: Uuid, thumbnail_path: String) -> CoreResult<()> {