refactor: split ImageRefPort into ImageRefCommand and ImageRefQuery

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

@@ -4,17 +4,17 @@ use async_trait::async_trait;
 use domain::{
     errors::DomainError,
     events::DomainEvent,
-    ports::{EventPublisher, ImageRefPort, PeriodicJob},
+    ports::{EventPublisher, ImageRefQuery, PeriodicJob},
 };
 
 pub struct ConversionBackfillJob {
-    image_ref: Arc<dyn ImageRefPort>,
+    image_ref: Arc<dyn ImageRefQuery>,
     event_publisher: Arc<dyn EventPublisher>,
 }
 
 impl ConversionBackfillJob {
     pub fn new(
-        image_ref: Arc<dyn ImageRefPort>,
+        image_ref: Arc<dyn ImageRefQuery>,
         event_publisher: Arc<dyn EventPublisher>,
     ) -> Self {
         Self { image_ref, event_publisher }
@@ -56,8 +56,7 @@ mod tests {
     }
 
     #[async_trait::async_trait]
-    impl ImageRefPort for MockImageRef {
-        async fn swap(&self, _: &str, _: &str) -> Result<(), DomainError> { Ok(()) }
+    impl ImageRefQuery for MockImageRef {
         async fn list_keys(&self) -> Result<Vec<String>, DomainError> {
             Ok(self.keys.clone())
         }

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

@@ -4,21 +4,21 @@ use async_trait::async_trait;
 use domain::{
     errors::DomainError,
     events::DomainEvent,
-    ports::{EventHandler, ImageRefPort, ImageStorage},
+    ports::{EventHandler, ImageRefCommand, ImageStorage},
 };
 
 use crate::Format;
 
 pub struct ImageConversionHandler {
     storage: Arc<dyn ImageStorage>,
-    image_ref: Arc<dyn ImageRefPort>,
+    image_ref: Arc<dyn ImageRefCommand>,
     format: Format,
 }
 
 impl ImageConversionHandler {
     pub fn new(
         storage: Arc<dyn ImageStorage>,
-        image_ref: Arc<dyn ImageRefPort>,
+        image_ref: Arc<dyn ImageRefCommand>,
         format: Format,
     ) -> Self {
         Self { storage, image_ref, format }
@@ -50,7 +50,7 @@ impl EventHandler for ImageConversionHandler {
         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}");
+            tracing::error!("swap failed for {key} → {new_key}: {e}");
             return Err(e);
         }
 
@@ -113,14 +113,11 @@ mod tests {
     }
 
     #[async_trait::async_trait]
-    impl ImageRefPort for MockImageRef {
+    impl ImageRefCommand 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> {
@@ -143,7 +140,7 @@ mod tests {
         let image_ref = MockImageRef::new();
         let handler = ImageConversionHandler::new(
             Arc::clone(&storage) as Arc<dyn ImageStorage>,
-            Arc::clone(&image_ref) as Arc<dyn ImageRefPort>,
+            Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
             Format::Avif,
         );
 
@@ -161,7 +158,7 @@ mod tests {
         let image_ref = MockImageRef::new();
         let handler = ImageConversionHandler::new(
             Arc::clone(&storage) as Arc<dyn ImageStorage>,
-            Arc::clone(&image_ref) as Arc<dyn ImageRefPort>,
+            Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
             Format::Avif,
         );
 
@@ -177,7 +174,7 @@ mod tests {
         let image_ref = MockImageRef::new();
         let handler = ImageConversionHandler::new(
             Arc::clone(&storage) as Arc<dyn ImageStorage>,
-            Arc::clone(&image_ref) as Arc<dyn ImageRefPort>,
+            Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
             Format::Webp,
         );
 
@@ -193,7 +190,7 @@ mod tests {
         let image_ref = MockImageRef::new();
         let handler = ImageConversionHandler::new(
             Arc::clone(&storage) as Arc<dyn ImageStorage>,
-            Arc::clone(&image_ref) as Arc<dyn ImageRefPort>,
+            Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
             Format::Avif,
         );
 
@@ -211,7 +208,7 @@ mod tests {
         let image_ref = MockImageRef::new();
         let handler = ImageConversionHandler::new(
             Arc::clone(&storage) as Arc<dyn ImageStorage>,
-            Arc::clone(&image_ref) as Arc<dyn ImageRefPort>,
+            Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
             Format::Webp,
         );
 

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

@@ -7,11 +7,12 @@ pub use config::{ConversionConfig, Format};
 pub use handler::ImageConversionHandler;
 
 use std::sync::Arc;
-use domain::ports::{EventHandler, EventPublisher, ImageRefPort, ImageStorage, PeriodicJob};
+use domain::ports::{EventHandler, EventPublisher, ImageRefCommand, ImageRefQuery, ImageStorage, PeriodicJob};
 
 pub fn build(
     image_storage: Arc<dyn ImageStorage>,
-    image_ref: Arc<dyn ImageRefPort>,
+    image_ref_command: Arc<dyn ImageRefCommand>,
+    image_ref_query: Arc<dyn ImageRefQuery>,
     event_publisher: Arc<dyn EventPublisher>,
 ) -> anyhow::Result<Option<(Arc<dyn EventHandler>, Arc<dyn PeriodicJob>)>> {
     let config = match ConversionConfig::from_env()? {
@@ -23,12 +24,12 @@ pub fn build(
 
     let handler = Arc::new(ImageConversionHandler::new(
         Arc::clone(&image_storage),
-        Arc::clone(&image_ref),
+        image_ref_command,
         format,
     )) as Arc<dyn EventHandler>;
 
     let job = Arc::new(ConversionBackfillJob::new(
-        Arc::clone(&image_ref),
+        image_ref_query,
         Arc::clone(&event_publisher),
     )) as Arc<dyn PeriodicJob>;
 

crates/adapters/postgres/src/image_ref.rs

@@ -1,5 +1,5 @@
 use async_trait::async_trait;
-use domain::{errors::DomainError, ports::ImageRefPort};
+use domain::{errors::DomainError, ports::{ImageRefCommand, ImageRefQuery}};
 use sqlx::PgPool;
 use std::sync::Arc;
 
@@ -13,12 +13,13 @@ impl PostgresImageRefAdapter {
     }
 }
 
-pub fn create_image_ref(pool: PgPool) -> Arc<dyn ImageRefPort> {
-    Arc::new(PostgresImageRefAdapter::new(pool))
+pub fn create_image_ref(pool: PgPool) -> (Arc<dyn ImageRefCommand>, Arc<dyn ImageRefQuery>) {
+    let adapter = Arc::new(PostgresImageRefAdapter::new(pool));
+    (Arc::clone(&adapter) as Arc<dyn ImageRefCommand>, adapter as Arc<dyn ImageRefQuery>)
 }
 
 #[async_trait]
-impl ImageRefPort for PostgresImageRefAdapter {
+impl ImageRefCommand for PostgresImageRefAdapter {
     async fn swap(&self, old_key: &str, new_key: &str) -> Result<(), DomainError> {
         let mut tx = self.pool.begin().await
             .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
@@ -33,7 +34,10 @@ impl ImageRefPort for PostgresImageRefAdapter {
         tx.commit().await
             .map_err(|e| DomainError::InfrastructureError(e.to_string()))
     }
+}
 
+#[async_trait]
+impl ImageRefQuery for PostgresImageRefAdapter {
     async fn list_keys(&self) -> Result<Vec<String>, DomainError> {
         let rows: Vec<(String,)> = sqlx::query_as(
             "SELECT avatar_path FROM users WHERE avatar_path IS NOT NULL

crates/adapters/sqlite/src/image_ref.rs

@@ -1,5 +1,5 @@
 use async_trait::async_trait;
-use domain::{errors::DomainError, ports::ImageRefPort};
+use domain::{errors::DomainError, ports::{ImageRefCommand, ImageRefQuery}};
 use sqlx::SqlitePool;
 use std::sync::Arc;
 
@@ -13,12 +13,13 @@ impl SqliteImageRefAdapter {
     }
 }
 
-pub fn create_image_ref(pool: SqlitePool) -> Arc<dyn ImageRefPort> {
-    Arc::new(SqliteImageRefAdapter::new(pool))
+pub fn create_image_ref(pool: SqlitePool) -> (Arc<dyn ImageRefCommand>, Arc<dyn ImageRefQuery>) {
+    let adapter = Arc::new(SqliteImageRefAdapter::new(pool));
+    (Arc::clone(&adapter) as Arc<dyn ImageRefCommand>, adapter as Arc<dyn ImageRefQuery>)
 }
 
 #[async_trait]
-impl ImageRefPort for SqliteImageRefAdapter {
+impl ImageRefCommand for SqliteImageRefAdapter {
     async fn swap(&self, old_key: &str, new_key: &str) -> Result<(), DomainError> {
         let mut tx = self.pool.begin().await
             .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
@@ -33,7 +34,10 @@ impl ImageRefPort for SqliteImageRefAdapter {
         tx.commit().await
             .map_err(|e| DomainError::InfrastructureError(e.to_string()))
     }
+}
 
+#[async_trait]
+impl ImageRefQuery for SqliteImageRefAdapter {
     async fn list_keys(&self) -> Result<Vec<String>, DomainError> {
         let rows: Vec<(String,)> = sqlx::query_as(
             "SELECT avatar_path FROM users WHERE avatar_path IS NOT NULL