refactoring hexagonal and clean architecture

src/application/services/file_retrieval_service.rs

@@ -4,39 +4,258 @@ use bytes::Bytes;
 use futures::Stream;
 
 use crate::application::dtos::file_dto::FileDto;
-use crate::application::ports::file_ports::FileRetrievalUseCase;
+use crate::application::ports::file_ports::{FileRetrievalUseCase, OptimizedFileContent};
 use crate::application::ports::storage_ports::FileReadPort;
+use crate::application::ports::cache_ports::{WriteBehindCachePort, ContentCachePort};
+use crate::application::ports::transcode_ports::{ImageTranscodePort, OutputFormat};
 use crate::common::errors::DomainError;
+use tracing::{debug, info, warn};
+
+/// Threshold below which files are served from RAM cache (10 MB).
+const CACHE_THRESHOLD: u64 = 10 * 1024 * 1024;
+/// Threshold above which mmap is used instead of streaming (100 MB).
+const MMAP_THRESHOLD: u64 = 100 * 1024 * 1024;
 
 /// Servicio para operaciones de recuperación de archivos
+///
+/// Implements a multi-tier download strategy:
+/// - Tier 0: Write-behind cache (just-uploaded files still in RAM)
+/// - Tier 1: Hot cache + optional WebP transcoding (<10 MB)
+/// - Tier 2: Memory-mapped I/O (10–100 MB)
+/// - Tier 3: Streaming (≥100 MB)
 pub struct FileRetrievalService {
-    file_repository: Arc<dyn FileReadPort>,
+    file_read: Arc<dyn FileReadPort>,
+    write_behind: Option<Arc<dyn WriteBehindCachePort>>,
+    content_cache: Option<Arc<dyn ContentCachePort>>,
+    transcode: Option<Arc<dyn ImageTranscodePort>>,
 }
 
 impl FileRetrievalService {
-    /// Crea un nuevo servicio de recuperación de archivos
+    /// Backward-compatible constructor (simple pass-through).
     pub fn new(file_repository: Arc<dyn FileReadPort>) -> Self {
-        Self { file_repository }
+        Self {
+            file_read: file_repository,
+            write_behind: None,
+            content_cache: None,
+            transcode: None,
+        }
+    }
+
+    /// Full constructor with all infrastructure ports.
+    pub fn new_full(
+        file_read: Arc<dyn FileReadPort>,
+        write_behind: Arc<dyn WriteBehindCachePort>,
+        content_cache: Arc<dyn ContentCachePort>,
+        transcode: Arc<dyn ImageTranscodePort>,
+    ) -> Self {
+        Self {
+            file_read,
+            write_behind: Some(write_behind),
+            content_cache: Some(content_cache),
+            transcode: Some(transcode),
+        }
+    }
+
+    // ── private helpers ──────────────────────────────────────────
+
+    /// Try to transcode image content to WebP and return transcoded variant.
+    async fn try_transcode(
+        &self,
+        id: &str,
+        content: &Bytes,
+        mime: &str,
+        file_size: u64,
+        accept_webp: bool,
+    ) -> Option<(Bytes, String)> {
+        if !accept_webp {
+            return None;
+        }
+        let transcode = self.transcode.as_ref()?;
+        if !transcode.should_transcode(mime, file_size) {
+            return None;
+        }
+        let format = OutputFormat::WebP;
+        match transcode.get_transcoded(id, content, mime, format).await {
+            Ok((transcoded, webp_mime, true)) => {
+                debug!(
+                    "🖼️ WebP transcode: {} -> {} bytes ({:.0}% smaller)",
+                    content.len(),
+                    transcoded.len(),
+                    (1.0 - transcoded.len() as f64 / content.len().max(1) as f64) * 100.0
+                );
+                Some((transcoded, webp_mime))
+            }
+            _ => None,
+        }
     }
 }
 
 #[async_trait]
 impl FileRetrievalUseCase for FileRetrievalService {
     async fn get_file(&self, id: &str) -> Result<FileDto, DomainError> {
-        let file = self.file_repository.get_file(id).await?;
+        let file = self.file_read.get_file(id).await?;
         Ok(FileDto::from(file))
     }
-    
+
+    async fn get_file_by_path(&self, path: &str) -> Result<FileDto, DomainError> {
+        // Normalize the path (remove leading/trailing slashes)
+        let path = path.trim_start_matches('/').trim_end_matches('/');
+
+        // List all files and find the one with matching path
+        let all_files = self.list_files(None).await?;
+
+        for file in all_files {
+            let file_path = file.path.trim_start_matches('/').trim_end_matches('/');
+            if file_path == path
+                || file_path.ends_with(&format!("/{}", path))
+                || path.ends_with(&format!("/{}", file_path))
+            {
+                return Ok(file);
+            }
+        }
+
+        Err(DomainError::not_found("File", format!("not found at path: {}", path)))
+    }
+
     async fn list_files(&self, folder_id: Option<&str>) -> Result<Vec<FileDto>, DomainError> {
-        let files = self.file_repository.list_files(folder_id).await?;
+        let files = self.file_read.list_files(folder_id).await?;
         Ok(files.into_iter().map(FileDto::from).collect())
     }
-    
+
     async fn get_file_content(&self, id: &str) -> Result<Vec<u8>, DomainError> {
-        self.file_repository.get_file_content(id).await
+        self.file_read.get_file_content(id).await
     }
-    
-    async fn get_file_stream(&self, id: &str) -> Result<Box<dyn Stream<Item = Result<Bytes, std::io::Error>> + Send>, DomainError> {
-        self.file_repository.get_file_stream(id).await
+
+    async fn get_file_stream(
+        &self,
+        id: &str,
+    ) -> Result<Box<dyn Stream<Item = Result<Bytes, std::io::Error>> + Send>, DomainError> {
+        self.file_read.get_file_stream(id).await
+    }
+
+    /// Multi-tier optimized download.
+    async fn get_file_optimized(
+        &self,
+        id: &str,
+        accept_webp: bool,
+        prefer_original: bool,
+    ) -> Result<(FileDto, OptimizedFileContent), DomainError> {
+        let file = self.file_read.get_file(id).await?;
+        let dto = FileDto::from(file);
+        let mime_type = dto.mime_type.clone();
+        let file_size = dto.size;
+        let file_name = dto.name.clone();
+        let modified_at = dto.modified_at.clone();
+        let do_transcode = accept_webp && !prefer_original;
+
+        // ── Tier 0: Write-behind cache ───────────────────────
+        if let Some(wb) = &self.write_behind {
+            if let Some(pending) = wb.get_pending(id).await {
+                debug!("⚡ TIER 0 Write-Behind HIT: {} ({} bytes)", file_name, pending.len());
+                let (data, mime) = if do_transcode {
+                    if let Some((t, m)) = self.try_transcode(id, &pending, &mime_type, file_size, true).await {
+                        (t, m)
+                    } else {
+                        (pending, mime_type.clone())
+                    }
+                } else {
+                    (pending, mime_type.clone())
+                };
+                return Ok((dto, OptimizedFileContent::Bytes {
+                    data,
+                    mime_type: mime,
+                    was_transcoded: do_transcode,
+                }));
+            }
+        }
+
+        // ── Tier 1: Hot cache + transcode (<10 MB) ──────────
+        if file_size < CACHE_THRESHOLD {
+            // Check content cache first
+            if let Some(cache) = &self.content_cache {
+                if let Some((cached, _etag, _ct)) = cache.get(id).await {
+                    debug!("🔥 TIER 1 Cache HIT: {} ({} bytes)", file_name, cached.len());
+                    if do_transcode {
+                        if let Some((t, m)) = self.try_transcode(id, &cached, &mime_type, file_size, true).await {
+                            return Ok((dto, OptimizedFileContent::Bytes {
+                                data: t,
+                                mime_type: m,
+                                was_transcoded: true,
+                            }));
+                        }
+                    }
+                    return Ok((dto, OptimizedFileContent::Bytes {
+                        data: cached,
+                        mime_type: mime_type.clone(),
+                        was_transcoded: false,
+                    }));
+                }
+            }
+
+            // Cache miss – load from disk
+            debug!("💾 TIER 1 Cache MISS: {} – loading from disk", file_name);
+            let content = self.file_read.get_file_content(id).await?;
+            let content_bytes = Bytes::from(content);
+
+            // Store in cache
+            if let Some(cache) = &self.content_cache {
+                let etag = format!("\"{}-{}\"", id, modified_at);
+                cache.put(id.to_string(), content_bytes.clone(), etag, mime_type.clone()).await;
+            }
+
+            if do_transcode {
+                if let Some((t, m)) = self.try_transcode(id, &content_bytes, &mime_type, file_size, true).await {
+                    return Ok((dto, OptimizedFileContent::Bytes {
+                        data: t,
+                        mime_type: m,
+                        was_transcoded: true,
+                    }));
+                }
+            }
+            return Ok((dto, OptimizedFileContent::Bytes {
+                data: content_bytes,
+                mime_type: mime_type.clone(),
+                was_transcoded: false,
+            }));
+        }
+
+        // ── Tier 2: MMAP (10–100 MB) ────────────────────────
+        if file_size < MMAP_THRESHOLD {
+            info!("🗺️ TIER 2 MMAP: {} ({} MB)", file_name, file_size / (1024 * 1024));
+            match self.file_read.get_file_mmap(id).await {
+                Ok(mmap_content) => {
+                    return Ok((dto, OptimizedFileContent::Mmap(mmap_content)));
+                }
+                Err(e) => {
+                    warn!("MMAP failed, falling back to streaming: {}", e);
+                    // fall through to streaming
+                }
+            }
+        }
+
+        // ── Tier 3: Streaming (≥100 MB) ─────────────────────
+        info!("📡 TIER 3 STREAMING: {} ({} MB)", file_name, file_size / (1024 * 1024));
+        match self.file_read.get_file_stream(id).await {
+            Ok(stream) => Ok((dto, OptimizedFileContent::Stream(Box::into_pin(stream)))),
+            Err(e) => {
+                warn!("Streaming failed, last-resort content load: {}", e);
+                let content = self.file_read.get_file_content(id).await?;
+                Ok((dto, OptimizedFileContent::Bytes {
+                    data: Bytes::from(content),
+                    mime_type: mime_type.clone(),
+                    was_transcoded: false,
+                }))
+            }
+        }
+    }
+
+    /// Range-based streaming for HTTP Range Requests.
+    async fn get_file_range_stream(
+        &self,
+        id: &str,
+        start: u64,
+        end: Option<u64>,
+    ) -> Result<Box<dyn Stream<Item = Result<Bytes, std::io::Error>> + Send>, DomainError> {
+        self.file_read.get_file_range_stream(id, start, end).await
     }
 }