feat: async image conversion service (avif/webp) with backfill

crates/adapters/image-converter/src/backfill.rs

@@ -0,0 +1,141 @@
+use std::{sync::Arc, time::Duration};
+
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    ports::{EventPublisher, ImageRefPort, PeriodicJob},
+};
+
+pub struct ConversionBackfillJob {
+    image_ref: Arc<dyn ImageRefPort>,
+    event_publisher: Arc<dyn EventPublisher>,
+}
+
+impl ConversionBackfillJob {
+    pub fn new(
+        image_ref: Arc<dyn ImageRefPort>,
+        event_publisher: Arc<dyn EventPublisher>,
+    ) -> Self {
+        Self { image_ref, event_publisher }
+    }
+}
+
+#[async_trait]
+impl PeriodicJob for ConversionBackfillJob {
+    fn interval(&self) -> Duration {
+        Duration::from_secs(60 * 60 * 24) // 24h
+    }
+
+    async fn run(&self) -> Result<(), DomainError> {
+        let keys = self.image_ref.list_keys().await?;
+
+        for key in keys {
+            if key.ends_with(".avif") || key.ends_with(".webp") {
+                continue;
+            }
+            if let Err(e) = self.event_publisher
+                .publish(&DomainEvent::ImageStored { key: key.clone() })
+                .await
+            {
+                tracing::warn!("backfill: failed to emit ImageStored for {key}: {e}");
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+
+    struct MockImageRef {
+        keys: Vec<String>,
+    }
+
+    #[async_trait::async_trait]
+    impl ImageRefPort for MockImageRef {
+        async fn swap(&self, _: &str, _: &str) -> Result<(), DomainError> { Ok(()) }
+        async fn list_keys(&self) -> Result<Vec<String>, DomainError> {
+            Ok(self.keys.clone())
+        }
+    }
+
+    struct MockPublisher {
+        emitted: Mutex<Vec<String>>,
+    }
+
+    impl MockPublisher {
+        fn new() -> Arc<Self> {
+            Arc::new(Self { emitted: Mutex::new(vec![]) })
+        }
+
+        fn emitted(&self) -> Vec<String> {
+            self.emitted.lock().unwrap().clone()
+        }
+    }
+
+    #[async_trait::async_trait]
+    impl EventPublisher for MockPublisher {
+        async fn publish(&self, event: &DomainEvent) -> Result<(), DomainError> {
+            if let DomainEvent::ImageStored { key } = event {
+                self.emitted.lock().unwrap().push(key.clone());
+            }
+            Ok(())
+        }
+    }
+
+    #[tokio::test]
+    async fn emits_image_stored_for_unconverted_keys() {
+        let image_ref = Arc::new(MockImageRef {
+            keys: vec!["avatars/u1".into(), "posters/m1".into()],
+        });
+        let publisher = MockPublisher::new();
+        let job = ConversionBackfillJob::new(
+            image_ref,
+            Arc::clone(&publisher) as Arc<dyn EventPublisher>,
+        );
+
+        job.run().await.unwrap();
+
+        let mut emitted = publisher.emitted();
+        emitted.sort();
+        assert_eq!(emitted, vec!["avatars/u1", "posters/m1"]);
+    }
+
+    #[tokio::test]
+    async fn skips_already_converted_keys() {
+        let image_ref = Arc::new(MockImageRef {
+            keys: vec![
+                "avatars/u1.avif".into(),
+                "posters/m1".into(),
+                "avatars/u2.webp".into(),
+            ],
+        });
+        let publisher = MockPublisher::new();
+        let job = ConversionBackfillJob::new(
+            image_ref,
+            Arc::clone(&publisher) as Arc<dyn EventPublisher>,
+        );
+
+        job.run().await.unwrap();
+
+        assert_eq!(publisher.emitted(), vec!["posters/m1"]);
+    }
+
+    #[tokio::test]
+    async fn empty_keys_emits_nothing() {
+        let image_ref = Arc::new(MockImageRef { keys: vec![] });
+        let publisher = MockPublisher::new();
+        let job = ConversionBackfillJob::new(
+            image_ref,
+            Arc::clone(&publisher) as Arc<dyn EventPublisher>,
+        );
+
+        job.run().await.unwrap();
+
+        assert!(publisher.emitted().is_empty());
+    }
+}

crates/adapters/image-converter/src/config.rs

@@ -0,0 +1,90 @@
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Format {
+    Avif,
+    Webp,
+}
+
+impl Format {
+    pub fn extension(self) -> &'static str {
+        match self {
+            Format::Avif => ".avif",
+            Format::Webp => ".webp",
+        }
+    }
+}
+
+pub struct ConversionConfig {
+    pub format: Format,
+}
+
+impl ConversionConfig {
+    pub fn from_env() -> anyhow::Result<Option<Self>> {
+        Self::from_vars(
+            std::env::var("IMAGE_CONVERSION_ENABLED").ok().as_deref(),
+            std::env::var("IMAGE_CONVERSION_FORMAT").ok().as_deref(),
+        )
+    }
+
+    fn from_vars(enabled: Option<&str>, format: Option<&str>) -> anyhow::Result<Option<Self>> {
+        if enabled != Some("true") {
+            return Ok(None);
+        }
+
+        let format_str = format.ok_or_else(|| {
+            anyhow::anyhow!("IMAGE_CONVERSION_FORMAT required when IMAGE_CONVERSION_ENABLED=true")
+        })?;
+
+        let format = match format_str {
+            "avif" => Format::Avif,
+            "webp" => Format::Webp,
+            other => anyhow::bail!(
+                "Unknown IMAGE_CONVERSION_FORMAT: {other:?}. Valid values: avif, webp"
+            ),
+        };
+
+        Ok(Some(Self { format }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn disabled_by_default() {
+        assert!(ConversionConfig::from_vars(None, None).unwrap().is_none());
+        assert!(ConversionConfig::from_vars(Some("false"), None).unwrap().is_none());
+    }
+
+    #[test]
+    fn enabled_avif() {
+        let cfg = ConversionConfig::from_vars(Some("true"), Some("avif")).unwrap().unwrap();
+        assert_eq!(cfg.format, Format::Avif);
+    }
+
+    #[test]
+    fn enabled_webp() {
+        let cfg = ConversionConfig::from_vars(Some("true"), Some("webp")).unwrap().unwrap();
+        assert_eq!(cfg.format, Format::Webp);
+    }
+
+    #[test]
+    fn unknown_format_is_error() {
+        assert!(ConversionConfig::from_vars(Some("true"), Some("gif")).is_err());
+    }
+
+    #[test]
+    fn missing_format_when_enabled_is_error() {
+        assert!(ConversionConfig::from_vars(Some("true"), None).is_err());
+    }
+
+    #[test]
+    fn avif_extension() {
+        assert_eq!(Format::Avif.extension(), ".avif");
+    }
+
+    #[test]
+    fn webp_extension() {
+        assert_eq!(Format::Webp.extension(), ".webp");
+    }
+}

crates/adapters/image-converter/src/handler.rs

@@ -0,0 +1,224 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    ports::{EventHandler, ImageRefPort, ImageStorage},
+};
+
+use crate::Format;
+
+pub struct ImageConversionHandler {
+    storage: Arc<dyn ImageStorage>,
+    image_ref: Arc<dyn ImageRefPort>,
+    format: Format,
+}
+
+impl ImageConversionHandler {
+    pub fn new(
+        storage: Arc<dyn ImageStorage>,
+        image_ref: Arc<dyn ImageRefPort>,
+        format: Format,
+    ) -> Self {
+        Self { storage, image_ref, format }
+    }
+}
+
+#[async_trait]
+impl EventHandler for ImageConversionHandler {
+    async fn handle(&self, event: &DomainEvent) -> Result<(), DomainError> {
+        let key = match event {
+            DomainEvent::ImageStored { key } => key.clone(),
+            _ => return Ok(()),
+        };
+
+        if key.ends_with(".avif") || key.ends_with(".webp") {
+            return Ok(());
+        }
+
+        let bytes = self.storage.get(&key).await?;
+        let format = self.format;
+
+        let converted = tokio::task::spawn_blocking(move || convert(bytes, format))
+            .await
+            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?
+            .map_err(|e| DomainError::InfrastructureError(e))?;
+
+        let ext = format.extension();
+        let new_key = format!("{key}{ext}");
+        self.storage.store(&new_key, &converted).await?;
+
+        if let Err(e) = self.image_ref.swap(&key, &new_key).await {
+            tracing::error!("ImageRefPort::swap failed for {key} → {new_key}: {e}");
+            return Err(e);
+        }
+
+        if let Err(e) = self.storage.delete(&key).await {
+            tracing::warn!("failed to delete old image key {key}: {e}");
+        }
+
+        tracing::info!("converted {key} → {new_key}");
+        Ok(())
+    }
+}
+
+fn convert(bytes: Vec<u8>, format: Format) -> Result<Vec<u8>, String> {
+    let img = image::load_from_memory(&bytes).map_err(|e| e.to_string())?;
+
+    match format {
+        Format::Avif => {
+            let rgba = img.to_rgba8();
+            let width = rgba.width() as usize;
+            let height = rgba.height() as usize;
+            let pixels: Vec<ravif::RGBA8> = rgba
+                .pixels()
+                .map(|p| ravif::RGBA8 { r: p.0[0], g: p.0[1], b: p.0[2], a: p.0[3] })
+                .collect();
+            let result = ravif::Encoder::new()
+                .with_quality(80.0)
+                .with_speed(6)
+                .encode_rgba(ravif::Img::new(&pixels, width, height))
+                .map_err(|e| e.to_string())?;
+            Ok(result.avif_file.to_vec())
+        }
+        Format::Webp => {
+            let rgba = img.to_rgba8();
+            let (width, height) = (rgba.width(), rgba.height());
+            let encoder = webp::Encoder::from_rgba(rgba.as_raw(), width, height);
+            Ok(encoder.encode(80.0).to_vec())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+    use object_store::memory::InMemory;
+    use image_storage::ImageStorageAdapter;
+
+    struct MockImageRef {
+        swaps: Mutex<Vec<(String, String)>>,
+    }
+
+    impl MockImageRef {
+        fn new() -> Arc<Self> {
+            Arc::new(Self { swaps: Mutex::new(vec![]) })
+        }
+
+        fn swaps(&self) -> Vec<(String, String)> {
+            self.swaps.lock().unwrap().clone()
+        }
+    }
+
+    #[async_trait::async_trait]
+    impl ImageRefPort for MockImageRef {
+        async fn swap(&self, old: &str, new: &str) -> Result<(), DomainError> {
+            self.swaps.lock().unwrap().push((old.into(), new.into()));
+            Ok(())
+        }
+        async fn list_keys(&self) -> Result<Vec<String>, DomainError> {
+            Ok(vec![])
+        }
+    }
+
+    fn in_memory_storage() -> Arc<ImageStorageAdapter> {
+        Arc::new(ImageStorageAdapter::new(Arc::new(InMemory::new())))
+    }
+
+    fn tiny_jpeg() -> Vec<u8> {
+        use image::{DynamicImage, ImageBuffer, Rgb};
+        let img = DynamicImage::ImageRgb8(
+            ImageBuffer::from_pixel(4, 4, Rgb([200u8, 100, 50])),
+        );
+        let mut buf = std::io::Cursor::new(Vec::new());
+        img.write_to(&mut buf, image::ImageFormat::Jpeg).unwrap();
+        buf.into_inner()
+    }
+
+    #[tokio::test]
+    async fn ignores_non_image_stored_events() {
+        let storage = in_memory_storage();
+        let image_ref = MockImageRef::new();
+        let handler = ImageConversionHandler::new(
+            Arc::clone(&storage) as Arc<dyn ImageStorage>,
+            Arc::clone(&image_ref) as Arc<dyn ImageRefPort>,
+            Format::Avif,
+        );
+
+        handler.handle(&DomainEvent::UserUpdated {
+            user_id: domain::value_objects::UserId::from_uuid(uuid::Uuid::new_v4()),
+        }).await.unwrap();
+
+        assert!(image_ref.swaps().is_empty());
+    }
+
+    #[tokio::test]
+    async fn skips_already_converted_avif_key() {
+        let storage = in_memory_storage();
+        storage.store("avatars/u1.avif", &tiny_jpeg()).await.unwrap();
+        let image_ref = MockImageRef::new();
+        let handler = ImageConversionHandler::new(
+            Arc::clone(&storage) as Arc<dyn ImageStorage>,
+            Arc::clone(&image_ref) as Arc<dyn ImageRefPort>,
+            Format::Avif,
+        );
+
+        handler.handle(&DomainEvent::ImageStored { key: "avatars/u1.avif".into() }).await.unwrap();
+
+        assert!(image_ref.swaps().is_empty());
+    }
+
+    #[tokio::test]
+    async fn skips_already_converted_webp_key() {
+        let storage = in_memory_storage();
+        storage.store("posters/m1.webp", &tiny_jpeg()).await.unwrap();
+        let image_ref = MockImageRef::new();
+        let handler = ImageConversionHandler::new(
+            Arc::clone(&storage) as Arc<dyn ImageStorage>,
+            Arc::clone(&image_ref) as Arc<dyn ImageRefPort>,
+            Format::Webp,
+        );
+
+        handler.handle(&DomainEvent::ImageStored { key: "posters/m1.webp".into() }).await.unwrap();
+
+        assert!(image_ref.swaps().is_empty());
+    }
+
+    #[tokio::test]
+    async fn converts_jpeg_to_avif_and_swaps_key() {
+        let storage = in_memory_storage();
+        storage.store("avatars/u1", &tiny_jpeg()).await.unwrap();
+        let image_ref = MockImageRef::new();
+        let handler = ImageConversionHandler::new(
+            Arc::clone(&storage) as Arc<dyn ImageStorage>,
+            Arc::clone(&image_ref) as Arc<dyn ImageRefPort>,
+            Format::Avif,
+        );
+
+        handler.handle(&DomainEvent::ImageStored { key: "avatars/u1".into() }).await.unwrap();
+
+        assert_eq!(image_ref.swaps(), vec![("avatars/u1".into(), "avatars/u1.avif".into())]);
+        assert!(storage.get("avatars/u1.avif").await.is_ok());
+        assert!(storage.get("avatars/u1").await.is_err());
+    }
+
+    #[tokio::test]
+    async fn converts_jpeg_to_webp_and_swaps_key() {
+        let storage = in_memory_storage();
+        storage.store("avatars/u1", &tiny_jpeg()).await.unwrap();
+        let image_ref = MockImageRef::new();
+        let handler = ImageConversionHandler::new(
+            Arc::clone(&storage) as Arc<dyn ImageStorage>,
+            Arc::clone(&image_ref) as Arc<dyn ImageRefPort>,
+            Format::Webp,
+        );
+
+        handler.handle(&DomainEvent::ImageStored { key: "avatars/u1".into() }).await.unwrap();
+
+        assert_eq!(image_ref.swaps(), vec![("avatars/u1".into(), "avatars/u1.webp".into())]);
+        assert!(storage.get("avatars/u1.webp").await.is_ok());
+        assert!(storage.get("avatars/u1").await.is_err());
+    }
+}

crates/adapters/image-converter/src/lib.rs

@@ -0,0 +1,36 @@
+mod backfill;
+mod config;
+mod handler;
+
+pub use backfill::ConversionBackfillJob;
+pub use config::{ConversionConfig, Format};
+pub use handler::ImageConversionHandler;
+
+use std::sync::Arc;
+use domain::ports::{EventHandler, EventPublisher, ImageRefPort, ImageStorage, PeriodicJob};
+
+pub fn build(
+    image_storage: Arc<dyn ImageStorage>,
+    image_ref: Arc<dyn ImageRefPort>,
+    event_publisher: Arc<dyn EventPublisher>,
+) -> anyhow::Result<Option<(Arc<dyn EventHandler>, Arc<dyn PeriodicJob>)>> {
+    let config = match ConversionConfig::from_env()? {
+        Some(c) => c,
+        None => return Ok(None),
+    };
+
+    let format = config.format;
+
+    let handler = Arc::new(ImageConversionHandler::new(
+        Arc::clone(&image_storage),
+        Arc::clone(&image_ref),
+        format,
+    )) as Arc<dyn EventHandler>;
+
+    let job = Arc::new(ConversionBackfillJob::new(
+        Arc::clone(&image_ref),
+        Arc::clone(&event_publisher),
+    )) as Arc<dyn PeriodicJob>;
+
+    Ok(Some((handler, job)))
+}