refactor: restructure domain crate by bounded context

crates/domain/tests/common/events.rs

@@ -0,0 +1,14 @@
+use domain::events::DomainEvent;
+use domain::value_objects::{DateTimeStamp, SystemId};
+
+#[test]
+fn asset_ingested_serde_roundtrip() {
+    let event = DomainEvent::AssetIngested {
+        asset_id: SystemId::new(),
+        owner_user_id: SystemId::new(),
+        timestamp: DateTimeStamp::now(),
+    };
+    let json = serde_json::to_string(&event).unwrap();
+    let back: DomainEvent = serde_json::from_str(&json).unwrap();
+    assert!(matches!(back, DomainEvent::AssetIngested { .. }));
+}

crates/domain/tests/common/mod.rs

@@ -0,0 +1,2 @@
+mod value_objects;
+mod events;

crates/domain/tests/common/value_objects/checksum.rs

@@ -0,0 +1,27 @@
+use domain::value_objects::Checksum;
+
+#[test]
+fn accepts_valid_sha256() {
+    let hex = "a".repeat(64);
+    assert!(Checksum::new(&hex).is_ok());
+}
+
+#[test]
+fn rejects_short() {
+    let hex = "a".repeat(63);
+    assert!(Checksum::new(&hex).is_err());
+}
+
+#[test]
+fn rejects_non_hex() {
+    let mut hex = "a".repeat(63);
+    hex.push('g');
+    assert!(Checksum::new(&hex).is_err());
+}
+
+#[test]
+fn normalizes_to_lowercase() {
+    let hex = "A".repeat(64);
+    let cs = Checksum::new(&hex).unwrap();
+    assert_eq!(cs.as_str(), "a".repeat(64));
+}

crates/domain/tests/common/value_objects/date_time_stamp.rs

@@ -0,0 +1,30 @@
+use chrono::Utc;
+use domain::value_objects::DateTimeStamp;
+
+#[test]
+fn now_is_recent() {
+    let before = Utc::now();
+    let ts = DateTimeStamp::now();
+    let after = Utc::now();
+    assert!(*ts.as_datetime() >= before);
+    assert!(*ts.as_datetime() <= after);
+}
+
+#[test]
+fn ordering() {
+    let a = DateTimeStamp::from_datetime(
+        chrono::DateTime::parse_from_rfc3339("2024-01-01T00:00:00Z").unwrap().into(),
+    );
+    let b = DateTimeStamp::from_datetime(
+        chrono::DateTime::parse_from_rfc3339("2025-01-01T00:00:00Z").unwrap().into(),
+    );
+    assert!(a < b);
+}
+
+#[test]
+fn serde_roundtrip() {
+    let ts = DateTimeStamp::now();
+    let json = serde_json::to_string(&ts).unwrap();
+    let back: DateTimeStamp = serde_json::from_str(&json).unwrap();
+    assert_eq!(ts, back);
+}

crates/domain/tests/common/value_objects/filter_criteria.rs

@@ -0,0 +1,13 @@
+use domain::value_objects::{FilterCriteria, FilterOperator};
+
+#[test]
+fn serde_roundtrip() {
+    let criteria = FilterCriteria::and(vec![
+        FilterCriteria::condition("rating", FilterOperator::GreaterThan, serde_json::json!(3)),
+        FilterCriteria::condition("type", FilterOperator::Equals, serde_json::json!("image")),
+    ]);
+
+    let json = serde_json::to_string(&criteria).unwrap();
+    let back: FilterCriteria = serde_json::from_str(&json).unwrap();
+    assert_eq!(criteria, back);
+}

crates/domain/tests/common/value_objects/mod.rs

@@ -0,0 +1,5 @@
+mod checksum;
+mod date_time_stamp;
+mod filter_criteria;
+mod structured_data;
+mod system_id;

crates/domain/tests/common/value_objects/structured_data.rs

@@ -0,0 +1,45 @@
+use domain::value_objects::{MetadataValue, StructuredData};
+
+#[test]
+fn insert_and_get() {
+    let mut sd = StructuredData::new();
+    sd.insert("key", MetadataValue::String("value".into()));
+    assert_eq!(sd.get_string("key"), Some("value"));
+    assert_eq!(sd.len(), 1);
+    assert!(!sd.is_empty());
+}
+
+#[test]
+fn merge_from_overwrites() {
+    let mut a = StructuredData::new();
+    a.insert("k", MetadataValue::Integer(1));
+
+    let mut b = StructuredData::new();
+    b.insert("k", MetadataValue::Integer(2));
+
+    a.merge_from(b);
+    assert!(matches!(a.get("k"), Some(MetadataValue::Integer(2))));
+}
+
+#[test]
+fn serde_roundtrip() {
+    let mut sd = StructuredData::new();
+    sd.insert("s", MetadataValue::String("hello".into()));
+    sd.insert("i", MetadataValue::Integer(42));
+    sd.insert("f", MetadataValue::Float(3.14));
+    sd.insert("b", MetadataValue::Boolean(true));
+    sd.insert("n", MetadataValue::Null);
+
+    let json = serde_json::to_string(&sd).unwrap();
+    let back: StructuredData = serde_json::from_str(&json).unwrap();
+    assert_eq!(sd, back);
+}
+
+#[test]
+fn remove_works() {
+    let mut sd = StructuredData::new();
+    sd.insert("k", MetadataValue::Integer(1));
+    let removed = sd.remove("k");
+    assert!(matches!(removed, Some(MetadataValue::Integer(1))));
+    assert!(sd.is_empty());
+}

crates/domain/tests/common/value_objects/system_id.rs

@@ -0,0 +1,31 @@
+use domain::value_objects::SystemId;
+use uuid::Uuid;
+
+#[test]
+fn unique_generation() {
+    let a = SystemId::new();
+    let b = SystemId::new();
+    assert_ne!(a, b);
+}
+
+#[test]
+fn uuid_roundtrip() {
+    let uuid = Uuid::new_v4();
+    let id = SystemId::from_uuid(uuid);
+    assert_eq!(*id.as_uuid(), uuid);
+}
+
+#[test]
+fn display_matches_uuid() {
+    let uuid = Uuid::new_v4();
+    let id = SystemId::from_uuid(uuid);
+    assert_eq!(id.to_string(), uuid.to_string());
+}
+
+#[test]
+fn serde_roundtrip() {
+    let id = SystemId::new();
+    let json = serde_json::to_string(&id).unwrap();
+    let back: SystemId = serde_json::from_str(&json).unwrap();
+    assert_eq!(id, back);
+}