feat: real EXIF extraction via adapters-exif crate

- MetadataExtractorPort in domain (bytes → StructuredData)
- adapters-exif: NomExifExtractor using nom-exif, handles EXIF + TrackInfo
- Worker's MetadataExtractorPlugin delegates to port, no longer knows nom-exif
- Filters noisy binary tags (U8Array, Undefined, Unknown)

crates/adapters/exif/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "adapters-exif"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+domain   = { workspace = true }
+bytes    = { workspace = true }
+nom-exif = { version = "2.5", features = ["serde"] }

crates/adapters/exif/src/lib.rs

@@ -0,0 +1,80 @@
+use bytes::Bytes;
+use domain::{
+    errors::DomainError,
+    ports::MetadataExtractorPort,
+    value_objects::{MetadataValue, StructuredData},
+};
+use nom_exif::{ExifIter, MediaParser, MediaSource, TrackInfo};
+use std::io::Cursor;
+
+pub struct NomExifExtractor;
+
+impl MetadataExtractorPort for NomExifExtractor {
+    fn extract(&self, bytes: &Bytes) -> Result<StructuredData, DomainError> {
+        if bytes.is_empty() {
+            return Ok(StructuredData::new());
+        }
+
+        let ms = match MediaSource::seekable(Cursor::new(bytes.as_ref())) {
+            Ok(ms) => ms,
+            Err(_) => return Ok(StructuredData::new()),
+        };
+
+        let mut parser = MediaParser::new();
+        let mut data = StructuredData::new();
+
+        if ms.has_exif() {
+            let iter: ExifIter = match parser.parse(ms) {
+                Ok(iter) => iter,
+                Err(_) => return Ok(data),
+            };
+
+            for mut entry in iter {
+                let tag_name = match entry.tag() {
+                    Some(t) => t.to_string(),
+                    None => continue,
+                };
+
+                if tag_name.starts_with("Unknown(") {
+                    continue;
+                }
+
+                let value = match entry.take_result() {
+                    Ok(v) => v.to_string(),
+                    Err(_) => continue,
+                };
+
+                if is_noisy_value(&value) {
+                    continue;
+                }
+
+                data.insert(tag_name, MetadataValue::String(value));
+            }
+        } else {
+            let track_info = match parser.parse::<_, _, TrackInfo>(ms) {
+                Ok(info) => info,
+                Err(_) => return Ok(data),
+            };
+
+            for (key, val) in track_info {
+                data.insert(
+                    format!("track:{}", key),
+                    MetadataValue::String(val.to_string()),
+                );
+            }
+        }
+
+        Ok(data)
+    }
+}
+
+fn is_noisy_value(v: &str) -> bool {
+    v.starts_with("U16Array")
+        || v.starts_with("U32Array")
+        || v.starts_with("U8Array")
+        || v.starts_with("URationalArray")
+        || v.starts_with("Undefined")
+}
+
+#[cfg(test)]
+mod tests;

crates/adapters/exif/src/tests.rs

@@ -0,0 +1,19 @@
+use crate::NomExifExtractor;
+use bytes::Bytes;
+use domain::ports::MetadataExtractorPort;
+
+#[test]
+fn empty_bytes_returns_empty_data() {
+    let extractor = NomExifExtractor;
+    let result = extractor.extract(&Bytes::new());
+    assert!(result.is_ok());
+    assert!(result.unwrap().is_empty());
+}
+
+#[test]
+fn garbage_bytes_returns_empty_data() {
+    let extractor = NomExifExtractor;
+    let result = extractor.extract(&Bytes::from_static(b"not a real image file"));
+    assert!(result.is_ok());
+    assert!(result.unwrap().is_empty());
+}

crates/domain/src/catalog/ports.rs

@@ -3,8 +3,9 @@ use super::entities::{
     MetadataSource,
 };
 use crate::common::errors::DomainError;
-use crate::common::value_objects::{Checksum, SystemId};
+use crate::common::value_objects::{Checksum, StructuredData, SystemId};
 use async_trait::async_trait;
+use bytes::Bytes;
 
 // --- AssetRepository ---
 
@@ -74,3 +75,9 @@ pub trait DuplicateRepository: Send + Sync {
     async fn find_by_asset(&self, asset_id: &SystemId) -> Result<Vec<DuplicateGroup>, DomainError>;
     async fn save(&self, group: &DuplicateGroup) -> Result<(), DomainError>;
 }
+
+// --- MetadataExtractorPort ---
+
+pub trait MetadataExtractorPort: Send + Sync {
+    fn extract(&self, bytes: &Bytes) -> Result<StructuredData, DomainError>;
+}

crates/worker/Cargo.toml

@@ -15,6 +15,7 @@ adapters-postgres  = { path = "../adapters/postgres" }
 adapters-storage   = { workspace = true }
 adapters-nats      = { workspace = true }
 event-transport    = { workspace = true }
+adapters-exif      = { workspace = true }
 async-nats         = { workspace = true }
 
 futures           = { workspace = true }

crates/worker/src/factories/plugins.rs

@@ -1,6 +1,6 @@
 use crate::plugin_registry::InMemoryPluginRegistry;
 use crate::plugins::{MetadataExtractorPlugin, NoOpPlugin, SidecarSyncPlugin};
-use domain::ports::SidecarWriterPort;
+use domain::ports::{MetadataExtractorPort, SidecarWriterPort};
 use std::sync::Arc;
 
 use super::Repos;
@@ -9,6 +9,7 @@ pub fn build_plugin_registry(
     repos: &Repos,
     file_storage: Arc<dyn domain::ports::FileStoragePort>,
     sidecar_writer: Arc<dyn SidecarWriterPort>,
+    extractor: Arc<dyn MetadataExtractorPort>,
 ) -> InMemoryPluginRegistry {
     let mut registry = InMemoryPluginRegistry::new();
 
@@ -17,6 +18,7 @@ pub fn build_plugin_registry(
         repos.asset.clone(),
         file_storage,
         repos.metadata.clone(),
+        extractor,
     )));
 
     let export_handler = Arc::new(application::sidecar::ExportSidecarHandler::new(

crates/worker/src/main.rs

@@ -51,7 +51,14 @@ async fn main() -> anyhow::Result<()> {
         event_transport::CompositeEventPublisher::new(nats_publisher, event_store),
     );
 
-    let registry = Arc::new(build_plugin_registry(&repos, file_storage, sidecar_writer));
+    let extractor: Arc<dyn domain::ports::MetadataExtractorPort> =
+        Arc::new(adapters_exif::NomExifExtractor);
+    let registry = Arc::new(build_plugin_registry(
+        &repos,
+        file_storage,
+        sidecar_writer,
+        extractor,
+    ));
     let process_next = Arc::new(build_process_next_handler(
         &repos,
         registry,

crates/worker/src/plugins/metadata_extractor.rs

@@ -2,7 +2,10 @@ use async_trait::async_trait;
 use domain::{
     entities::{AssetMetadata, MetadataSource},
     errors::DomainError,
-    ports::{AssetMetadataRepository, AssetRepository, FileStoragePort, PluginExecutor},
+    ports::{
+        AssetMetadataRepository, AssetRepository, FileStoragePort, MetadataExtractorPort,
+        PluginExecutor,
+    },
     value_objects::{MetadataValue, StructuredData, SystemId},
 };
 use std::sync::Arc;
@@ -12,6 +15,7 @@ pub struct MetadataExtractorPlugin {
     asset_repo: Arc<dyn AssetRepository>,
     file_storage: Arc<dyn FileStoragePort>,
     metadata_repo: Arc<dyn AssetMetadataRepository>,
+    extractor: Arc<dyn MetadataExtractorPort>,
 }
 
 impl MetadataExtractorPlugin {
@@ -19,11 +23,13 @@ impl MetadataExtractorPlugin {
         asset_repo: Arc<dyn AssetRepository>,
         file_storage: Arc<dyn FileStoragePort>,
         metadata_repo: Arc<dyn AssetMetadataRepository>,
+        extractor: Arc<dyn MetadataExtractorPort>,
     ) -> Self {
         Self {
             asset_repo,
             file_storage,
             metadata_repo,
+            extractor,
         }
     }
 }
@@ -52,17 +58,16 @@ impl PluginExecutor for MetadataExtractorPlugin {
 
         let path = &asset.source_reference.relative_path;
         let data = self.file_storage.read_file(path).await?;
-        let file_size = data.len() as i64;
 
-        let mut extracted = StructuredData::new();
-        extracted.insert("file_size_bytes", MetadataValue::Integer(file_size));
+        let mut extracted = self.extractor.extract(&data)?;
+        extracted.insert("file_size_bytes", MetadataValue::Integer(data.len() as i64));
         extracted.insert("mime_type", MetadataValue::String(asset.mime_type.clone()));
 
         let metadata =
             AssetMetadata::new(asset_id, MetadataSource::ExifExtracted, extracted.clone());
         self.metadata_repo.save(&metadata).await?;
 
-        info!(asset_id = %asset_id, file_size, "extracted basic metadata");
+        info!(asset_id = %asset_id, tags = extracted.len(), "extracted metadata");
         Ok(extracted)
     }
 }