app: add sidecar sync commands (export, detect, import, resolve, full export/import)

crates/application/tests/sidecar/commands/detect_external_changes.rs

@@ -0,0 +1,63 @@
+use std::sync::Arc;
+use application::sidecar::{DetectExternalChangesCommand, DetectExternalChangesHandler};
+use application::sidecar::hash_helper::hash_structured_data;
+use application::testing::{InMemorySidecarRepository, InMemorySidecarWriter};
+use domain::entities::{SidecarRecord, SyncStatus};
+use domain::ports::{SidecarRepository, SidecarWriterPort};
+use domain::value_objects::{MetadataValue, StructuredData, SystemId};
+
+#[tokio::test]
+async fn detects_changed_sidecar() {
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+
+    let asset_id = SystemId::new();
+    let path = format!("sidecars/{}.xmp", asset_id);
+
+    // Write original data and create InSync record with its hash
+    let mut original = StructuredData::new();
+    original.insert("title", MetadataValue::String("Old".into()));
+    let hash = hash_structured_data(&original);
+    let mut record = SidecarRecord::new(asset_id, &path);
+    record.mark_synced(hash);
+    sidecar_repo.save(&record).await.unwrap();
+
+    // Simulate external edit: write different data to sidecar file
+    let mut modified = StructuredData::new();
+    modified.insert("title", MetadataValue::String("New".into()));
+    writer.write_sidecar(&modified, &path).await.unwrap();
+
+    let handler = DetectExternalChangesHandler::new(sidecar_repo.clone(), writer);
+    let changed = handler.execute(DetectExternalChangesCommand).await.unwrap();
+
+    assert_eq!(changed, 1);
+    let updated = sidecar_repo.find_by_asset(&asset_id).await.unwrap().unwrap();
+    assert_eq!(updated.sync_status, SyncStatus::PendingRead);
+}
+
+#[tokio::test]
+async fn ignores_unchanged_sidecar() {
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+
+    let asset_id = SystemId::new();
+    let path = format!("sidecars/{}.xmp", asset_id);
+
+    let mut data = StructuredData::new();
+    data.insert("title", MetadataValue::String("Same".into()));
+    let hash = hash_structured_data(&data);
+
+    let mut record = SidecarRecord::new(asset_id, &path);
+    record.mark_synced(hash);
+    sidecar_repo.save(&record).await.unwrap();
+
+    // Write identical data to sidecar file
+    writer.write_sidecar(&data, &path).await.unwrap();
+
+    let handler = DetectExternalChangesHandler::new(sidecar_repo.clone(), writer);
+    let changed = handler.execute(DetectExternalChangesCommand).await.unwrap();
+
+    assert_eq!(changed, 0);
+    let updated = sidecar_repo.find_by_asset(&asset_id).await.unwrap().unwrap();
+    assert_eq!(updated.sync_status, SyncStatus::InSync);
+}

crates/application/tests/sidecar/commands/export_sidecar.rs

@@ -0,0 +1,49 @@
+use std::sync::Arc;
+use application::sidecar::{ExportSidecarCommand, ExportSidecarHandler};
+use application::testing::{InMemoryAssetMetadataRepository, InMemorySidecarRepository, InMemorySidecarWriter};
+use domain::catalog::entities::{AssetMetadata, MetadataSource};
+use domain::entities::SyncStatus;
+use domain::ports::SidecarRepository;
+use domain::value_objects::{MetadataValue, StructuredData, SystemId};
+
+#[tokio::test]
+async fn exports_sidecar_marks_in_sync() {
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+
+    let asset_id = SystemId::new();
+    let mut data = StructuredData::new();
+    data.insert("title", MetadataValue::String("Beach".into()));
+    let metadata = AssetMetadata::new(asset_id, MetadataSource::UserEdited, data);
+    use domain::ports::AssetMetadataRepository;
+    meta_repo.save(&metadata).await.unwrap();
+
+    let handler = ExportSidecarHandler::new(meta_repo, sidecar_repo.clone(), writer.clone());
+    let record = handler.execute(ExportSidecarCommand { asset_id }).await.unwrap();
+
+    assert_eq!(record.sync_status, SyncStatus::InSync);
+    assert!(record.last_known_file_hash.is_some());
+
+    let written = writer.get(&record.sidecar_storage_path).await;
+    assert!(written.is_some());
+    assert_eq!(written.unwrap().get_string("title"), Some("Beach"));
+}
+
+#[tokio::test]
+async fn creates_new_record_if_none_exists() {
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+
+    let asset_id = SystemId::new();
+
+    let handler = ExportSidecarHandler::new(meta_repo, sidecar_repo.clone(), writer);
+    let record = handler.execute(ExportSidecarCommand { asset_id }).await.unwrap();
+
+    assert_eq!(record.asset_id, asset_id);
+    assert_eq!(record.sync_status, SyncStatus::InSync);
+
+    let saved = sidecar_repo.find_by_asset(&asset_id).await.unwrap();
+    assert!(saved.is_some());
+}

crates/application/tests/sidecar/commands/full_export.rs

@@ -0,0 +1,45 @@
+use std::sync::Arc;
+use application::sidecar::{FullExportCommand, FullExportHandler};
+use application::testing::{
+    InMemoryAssetRepository, InMemoryAssetMetadataRepository,
+    InMemorySidecarRepository, InMemorySidecarWriter,
+};
+use domain::catalog::entities::{Asset, AssetMetadata, AssetType, MetadataSource, SourceReference};
+use domain::ports::AssetRepository;
+use domain::value_objects::{Checksum, MetadataValue, StructuredData, SystemId};
+
+fn make_asset(owner: SystemId) -> Asset {
+    let source = SourceReference {
+        volume_id: SystemId::new(),
+        relative_path: "photos/img.jpg".into(),
+        checksum: Checksum::new("a".repeat(64)).unwrap(),
+    };
+    Asset::new(source, AssetType::Image, "image/jpeg", 1024, owner)
+}
+
+#[tokio::test]
+async fn exports_all_user_assets() {
+    let asset_repo = Arc::new(InMemoryAssetRepository::new());
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+
+    let owner = SystemId::new();
+    let a1 = make_asset(owner);
+    let a2 = make_asset(owner);
+    asset_repo.save(&a1).await.unwrap();
+    asset_repo.save(&a2).await.unwrap();
+
+    let mut data = StructuredData::new();
+    data.insert("title", MetadataValue::String("Sunset".into()));
+    use domain::ports::AssetMetadataRepository;
+    meta_repo.save(&AssetMetadata::new(a1.asset_id, MetadataSource::UserEdited, data)).await.unwrap();
+
+    let handler = FullExportHandler::new(asset_repo, meta_repo, sidecar_repo, writer.clone());
+    let count = handler.execute(FullExportCommand { owner_id: owner }).await.unwrap();
+
+    assert_eq!(count, 2);
+
+    let written = writer.get(&format!("sidecars/{}.xmp", a1.asset_id)).await;
+    assert!(written.is_some());
+}

crates/application/tests/sidecar/commands/full_import.rs

@@ -0,0 +1,65 @@
+use std::sync::Arc;
+use application::sidecar::{FullImportCommand, FullImportHandler};
+use application::testing::{
+    InMemoryAssetRepository, InMemoryAssetMetadataRepository,
+    InMemorySidecarRepository, InMemorySidecarWriter,
+};
+use domain::catalog::entities::{Asset, AssetType, MetadataSource, SourceReference};
+use domain::entities::SidecarRecord;
+use domain::ports::{AssetMetadataRepository, AssetRepository, SidecarRepository, SidecarWriterPort};
+use domain::value_objects::{Checksum, MetadataValue, StructuredData, SystemId};
+
+fn make_asset(owner: SystemId) -> Asset {
+    let source = SourceReference {
+        volume_id: SystemId::new(),
+        relative_path: "photos/img.jpg".into(),
+        checksum: Checksum::new("b".repeat(64)).unwrap(),
+    };
+    Asset::new(source, AssetType::Image, "image/jpeg", 2048, owner)
+}
+
+#[tokio::test]
+async fn imports_from_existing_sidecars() {
+    let asset_repo = Arc::new(InMemoryAssetRepository::new());
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+
+    let owner = SystemId::new();
+    let asset = make_asset(owner);
+    asset_repo.save(&asset).await.unwrap();
+
+    let path = format!("sidecars/{}.xmp", asset.asset_id);
+    let record = SidecarRecord::new(asset.asset_id, &path);
+    sidecar_repo.save(&record).await.unwrap();
+
+    let mut data = StructuredData::new();
+    data.insert("lens", MetadataValue::String("50mm".into()));
+    writer.write_sidecar(&data, &path).await.unwrap();
+
+    let handler = FullImportHandler::new(asset_repo, meta_repo.clone(), sidecar_repo, writer);
+    let count = handler.execute(FullImportCommand { owner_id: owner }).await.unwrap();
+
+    assert_eq!(count, 1);
+    let imported = meta_repo.find_by_asset_and_source(&asset.asset_id, MetadataSource::ExifExtracted).await.unwrap();
+    assert!(imported.is_some());
+    assert_eq!(imported.unwrap().data.get_string("lens"), Some("50mm"));
+}
+
+#[tokio::test]
+async fn skips_missing_sidecars() {
+    let asset_repo = Arc::new(InMemoryAssetRepository::new());
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+
+    let owner = SystemId::new();
+    let asset = make_asset(owner);
+    asset_repo.save(&asset).await.unwrap();
+    // No sidecar record, no sidecar file
+
+    let handler = FullImportHandler::new(asset_repo, meta_repo, sidecar_repo, writer);
+    let count = handler.execute(FullImportCommand { owner_id: owner }).await.unwrap();
+
+    assert_eq!(count, 0);
+}

crates/application/tests/sidecar/commands/import_sidecar.rs

@@ -0,0 +1,54 @@
+use std::sync::Arc;
+use application::sidecar::{ImportSidecarCommand, ImportSidecarHandler};
+use application::testing::{InMemoryAssetMetadataRepository, InMemorySidecarRepository, InMemorySidecarWriter};
+use domain::catalog::entities::MetadataSource;
+use domain::entities::{SidecarRecord, SyncStatus};
+use domain::errors::DomainError;
+use domain::ports::{SidecarRepository, SidecarWriterPort};
+use domain::value_objects::{MetadataValue, StructuredData, SystemId};
+
+#[tokio::test]
+async fn imports_pending_read_sidecar() {
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+
+    let asset_id = SystemId::new();
+    let path = format!("sidecars/{}.xmp", asset_id);
+
+    // Create PendingRead record
+    let mut record = SidecarRecord::new(asset_id, &path);
+    record.mark_pending_read();
+    sidecar_repo.save(&record).await.unwrap();
+
+    // Write sidecar file data
+    let mut data = StructuredData::new();
+    data.insert("camera", MetadataValue::String("Canon".into()));
+    writer.write_sidecar(&data, &path).await.unwrap();
+
+    let handler = ImportSidecarHandler::new(sidecar_repo.clone(), writer, meta_repo);
+    let metadata = handler.execute(ImportSidecarCommand { asset_id }).await.unwrap();
+
+    assert_eq!(metadata.metadata_source, MetadataSource::ExifExtracted);
+    assert_eq!(metadata.data.get_string("camera"), Some("Canon"));
+
+    let updated = sidecar_repo.find_by_asset(&asset_id).await.unwrap().unwrap();
+    assert_eq!(updated.sync_status, SyncStatus::InSync);
+}
+
+#[tokio::test]
+async fn rejects_non_pending_read() {
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+
+    let asset_id = SystemId::new();
+    let record = SidecarRecord::new(asset_id, "sidecars/x.xmp");
+    // Default status is PendingWrite, not PendingRead
+    sidecar_repo.save(&record).await.unwrap();
+
+    let handler = ImportSidecarHandler::new(sidecar_repo, writer, meta_repo);
+    let result = handler.execute(ImportSidecarCommand { asset_id }).await;
+
+    assert!(matches!(result, Err(DomainError::Validation(_))));
+}

crates/application/tests/sidecar/commands/mod.rs

@@ -0,0 +1,6 @@
+mod export_sidecar;
+mod detect_external_changes;
+mod import_sidecar;
+mod resolve_conflict;
+mod full_export;
+mod full_import;

crates/application/tests/sidecar/commands/resolve_conflict.rs

@@ -0,0 +1,85 @@
+use std::sync::Arc;
+use application::sidecar::{ResolveConflictCommand, ResolveConflictHandler};
+use application::testing::{InMemoryAssetMetadataRepository, InMemorySidecarRepository, InMemorySidecarWriter};
+use domain::catalog::entities::{AssetMetadata, MetadataSource};
+use domain::entities::{ConflictPolicy, SidecarRecord, SyncStatus};
+use domain::errors::DomainError;
+use domain::ports::{AssetMetadataRepository, SidecarRepository, SidecarWriterPort};
+use domain::value_objects::{MetadataValue, StructuredData, SystemId};
+
+fn conflict_record(asset_id: SystemId, path: &str) -> SidecarRecord {
+    let mut r = SidecarRecord::new(asset_id, path);
+    r.mark_conflict();
+    r
+}
+
+#[tokio::test]
+async fn db_wins_re_exports() {
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+
+    let asset_id = SystemId::new();
+    let path = format!("sidecars/{}.xmp", asset_id);
+
+    sidecar_repo.save(&conflict_record(asset_id, &path)).await.unwrap();
+
+    let mut data = StructuredData::new();
+    data.insert("title", MetadataValue::String("DB Value".into()));
+    meta_repo.save(&AssetMetadata::new(asset_id, MetadataSource::UserEdited, data)).await.unwrap();
+
+    let handler = ResolveConflictHandler::new(sidecar_repo.clone(), writer.clone(), meta_repo);
+    let record = handler.execute(ResolveConflictCommand {
+        asset_id,
+        policy: ConflictPolicy::DbWins,
+    }).await.unwrap();
+
+    assert_eq!(record.sync_status, SyncStatus::InSync);
+    let written = writer.get(&path).await.unwrap();
+    assert_eq!(written.get_string("title"), Some("DB Value"));
+}
+
+#[tokio::test]
+async fn file_wins_re_imports() {
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+
+    let asset_id = SystemId::new();
+    let path = format!("sidecars/{}.xmp", asset_id);
+
+    sidecar_repo.save(&conflict_record(asset_id, &path)).await.unwrap();
+
+    let mut file_data = StructuredData::new();
+    file_data.insert("title", MetadataValue::String("File Value".into()));
+    writer.write_sidecar(&file_data, &path).await.unwrap();
+
+    let handler = ResolveConflictHandler::new(sidecar_repo.clone(), writer, meta_repo.clone());
+    let record = handler.execute(ResolveConflictCommand {
+        asset_id,
+        policy: ConflictPolicy::FileWins,
+    }).await.unwrap();
+
+    assert_eq!(record.sync_status, SyncStatus::InSync);
+    let imported = meta_repo.find_by_asset_and_source(&asset_id, MetadataSource::ExifExtracted).await.unwrap();
+    assert!(imported.is_some());
+    assert_eq!(imported.unwrap().data.get_string("title"), Some("File Value"));
+}
+
+#[tokio::test]
+async fn user_decision_returns_error() {
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+
+    let asset_id = SystemId::new();
+    sidecar_repo.save(&conflict_record(asset_id, "sidecars/x.xmp")).await.unwrap();
+
+    let handler = ResolveConflictHandler::new(sidecar_repo, writer, meta_repo);
+    let result = handler.execute(ResolveConflictCommand {
+        asset_id,
+        policy: ConflictPolicy::RequireUserDecision,
+    }).await;
+
+    assert!(matches!(result, Err(DomainError::Validation(msg)) if msg.contains("Manual")));
+}

crates/application/tests/sidecar/mod.rs

@@ -0,0 +1 @@
+mod commands;