fmt

crates/adapters/event-payload/src/lib.rs

@@ -84,8 +84,7 @@ impl EventPayload {
 }
 
 fn parse_uuid(s: &str, field: &str) -> Result<Uuid, DomainError> {
-    Uuid::parse_str(s)
-        .map_err(|e| DomainError::InfrastructureError(format!("{field}: {e}")))
+    Uuid::parse_str(s).map_err(|e| DomainError::InfrastructureError(format!("{field}: {e}")))
 }
 
 fn parse_ts(ts: i64) -> Result<NaiveDateTime, DomainError> {
@@ -97,31 +96,43 @@ fn parse_ts(ts: i64) -> Result<NaiveDateTime, DomainError> {
 impl From<&DomainEvent> for EventPayload {
     fn from(event: &DomainEvent) -> Self {
         match event {
-            DomainEvent::ReviewLogged { review_id, movie_id, user_id, rating, watched_at } => {
-                EventPayload::ReviewLogged {
-                    review_id: review_id.value().to_string(),
-                    movie_id: movie_id.value().to_string(),
-                    user_id: user_id.value().to_string(),
-                    rating: rating.value(),
-                    watched_at: watched_at.and_utc().timestamp(),
-                }
-            }
-            DomainEvent::ReviewUpdated { review_id, movie_id, user_id, rating, watched_at } => {
-                EventPayload::ReviewUpdated {
-                    review_id: review_id.value().to_string(),
-                    movie_id: movie_id.value().to_string(),
-                    user_id: user_id.value().to_string(),
-                    rating: rating.value(),
-                    watched_at: watched_at.and_utc().timestamp(),
-                }
-            }
-            DomainEvent::MovieDiscovered { movie_id, external_metadata_id } => {
-                EventPayload::MovieDiscovered {
-                    movie_id: movie_id.value().to_string(),
-                    external_metadata_id: external_metadata_id.value().to_owned(),
-                }
-            }
-            DomainEvent::MovieDeleted { movie_id, poster_path } => EventPayload::MovieDeleted {
+            DomainEvent::ReviewLogged {
+                review_id,
+                movie_id,
+                user_id,
+                rating,
+                watched_at,
+            } => EventPayload::ReviewLogged {
+                review_id: review_id.value().to_string(),
+                movie_id: movie_id.value().to_string(),
+                user_id: user_id.value().to_string(),
+                rating: rating.value(),
+                watched_at: watched_at.and_utc().timestamp(),
+            },
+            DomainEvent::ReviewUpdated {
+                review_id,
+                movie_id,
+                user_id,
+                rating,
+                watched_at,
+            } => EventPayload::ReviewUpdated {
+                review_id: review_id.value().to_string(),
+                movie_id: movie_id.value().to_string(),
+                user_id: user_id.value().to_string(),
+                rating: rating.value(),
+                watched_at: watched_at.and_utc().timestamp(),
+            },
+            DomainEvent::MovieDiscovered {
+                movie_id,
+                external_metadata_id,
+            } => EventPayload::MovieDiscovered {
+                movie_id: movie_id.value().to_string(),
+                external_metadata_id: external_metadata_id.value().to_owned(),
+            },
+            DomainEvent::MovieDeleted {
+                movie_id,
+                poster_path,
+            } => EventPayload::MovieDeleted {
                 movie_id: movie_id.value().to_string(),
                 poster_path: poster_path.as_ref().map(|p| p.value().to_string()),
             },
@@ -132,36 +143,44 @@ impl From<&DomainEvent> for EventPayload {
                 review_id: review_id.value().to_string(),
                 user_id: user_id.value().to_string(),
             },
-            DomainEvent::MovieEnrichmentRequested { movie_id, external_metadata_id } => {
-                EventPayload::MovieEnrichmentRequested {
-                    movie_id: movie_id.value().to_string(),
-                    external_metadata_id: external_metadata_id.clone(),
-                }
-            }
+            DomainEvent::MovieEnrichmentRequested {
+                movie_id,
+                external_metadata_id,
+            } => EventPayload::MovieEnrichmentRequested {
+                movie_id: movie_id.value().to_string(),
+                external_metadata_id: external_metadata_id.clone(),
+            },
             DomainEvent::ImageStored { key } => EventPayload::ImageStored { key: key.clone() },
-            DomainEvent::WatchlistEntryAdded { user_id, movie_id, movie_title, release_year, external_metadata_id, added_at } => {
-                EventPayload::WatchlistEntryAdded {
-                    user_id: user_id.value().to_string(),
-                    movie_id: movie_id.value().to_string(),
-                    movie_title: movie_title.clone(),
-                    release_year: *release_year,
-                    external_metadata_id: external_metadata_id.clone(),
-                    added_at: added_at.and_utc().timestamp(),
-                }
-            }
+            DomainEvent::WatchlistEntryAdded {
+                user_id,
+                movie_id,
+                movie_title,
+                release_year,
+                external_metadata_id,
+                added_at,
+            } => EventPayload::WatchlistEntryAdded {
+                user_id: user_id.value().to_string(),
+                movie_id: movie_id.value().to_string(),
+                movie_title: movie_title.clone(),
+                release_year: *release_year,
+                external_metadata_id: external_metadata_id.clone(),
+                added_at: added_at.and_utc().timestamp(),
+            },
             DomainEvent::WatchlistEntryRemoved { user_id, movie_id } => {
                 EventPayload::WatchlistEntryRemoved {
                     user_id: user_id.value().to_string(),
                     movie_id: movie_id.value().to_string(),
                 }
             }
-            DomainEvent::FollowAccepted { local_user_id, remote_actor_url, outbox_url } => {
-                EventPayload::FollowAccepted {
-                    local_user_id: local_user_id.value().to_string(),
-                    remote_actor_url: remote_actor_url.clone(),
-                    outbox_url: outbox_url.clone(),
-                }
-            }
+            DomainEvent::FollowAccepted {
+                local_user_id,
+                remote_actor_url,
+                outbox_url,
+            } => EventPayload::FollowAccepted {
+                local_user_id: local_user_id.value().to_string(),
+                remote_actor_url: remote_actor_url.clone(),
+                outbox_url: outbox_url.clone(),
+            },
         }
     }
 }
@@ -170,81 +189,98 @@ impl TryFrom<EventPayload> for DomainEvent {
     type Error = DomainError;
     fn try_from(payload: EventPayload) -> Result<Self, DomainError> {
         match payload {
-            EventPayload::ReviewLogged { review_id, movie_id, user_id, rating, watched_at } => {
-                Ok(DomainEvent::ReviewLogged {
-                    review_id: ReviewId::from_uuid(parse_uuid(&review_id, "review_id")?),
-                    movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
-                    user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                    rating: Rating::new(rating)?,
-                    watched_at: parse_ts(watched_at)?,
-                })
-            }
-            EventPayload::ReviewUpdated { review_id, movie_id, user_id, rating, watched_at } => {
-                Ok(DomainEvent::ReviewUpdated {
-                    review_id: ReviewId::from_uuid(parse_uuid(&review_id, "review_id")?),
-                    movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
-                    user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                    rating: Rating::new(rating)?,
-                    watched_at: parse_ts(watched_at)?,
-                })
-            }
-            EventPayload::MovieDiscovered { movie_id, external_metadata_id } => {
-                Ok(DomainEvent::MovieDiscovered {
-                    movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
-                    external_metadata_id: ExternalMetadataId::new(external_metadata_id)?,
-                })
-            }
-            EventPayload::MovieDeleted { movie_id, poster_path } => {
+            EventPayload::ReviewLogged {
+                review_id,
+                movie_id,
+                user_id,
+                rating,
+                watched_at,
+            } => Ok(DomainEvent::ReviewLogged {
+                review_id: ReviewId::from_uuid(parse_uuid(&review_id, "review_id")?),
+                movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
+                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
+                rating: Rating::new(rating)?,
+                watched_at: parse_ts(watched_at)?,
+            }),
+            EventPayload::ReviewUpdated {
+                review_id,
+                movie_id,
+                user_id,
+                rating,
+                watched_at,
+            } => Ok(DomainEvent::ReviewUpdated {
+                review_id: ReviewId::from_uuid(parse_uuid(&review_id, "review_id")?),
+                movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
+                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
+                rating: Rating::new(rating)?,
+                watched_at: parse_ts(watched_at)?,
+            }),
+            EventPayload::MovieDiscovered {
+                movie_id,
+                external_metadata_id,
+            } => Ok(DomainEvent::MovieDiscovered {
+                movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
+                external_metadata_id: ExternalMetadataId::new(external_metadata_id)?,
+            }),
+            EventPayload::MovieDeleted {
+                movie_id,
+                poster_path,
+            } => {
                 let movie_id = MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?);
                 let poster_path = poster_path
                     .map(PosterPath::new)
                     .transpose()
                     .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-                Ok(DomainEvent::MovieDeleted { movie_id, poster_path })
-            }
-            EventPayload::UserUpdated { user_id } => {
-                Ok(DomainEvent::UserUpdated {
-                    user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                })
-            }
-            EventPayload::ReviewDeleted { review_id, user_id } => {
-                Ok(DomainEvent::ReviewDeleted {
-                    review_id: ReviewId::from_uuid(parse_uuid(&review_id, "review_id")?),
-                    user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                })
-            }
-            EventPayload::MovieEnrichmentRequested { movie_id, external_metadata_id } => {
-                Ok(DomainEvent::MovieEnrichmentRequested {
-                    movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
-                    external_metadata_id,
-                })
-            }
-            EventPayload::ImageStored { key } => {
-                Ok(DomainEvent::ImageStored { key })
-            }
-            EventPayload::WatchlistEntryAdded { user_id, movie_id, movie_title, release_year, external_metadata_id, added_at } => {
-                Ok(DomainEvent::WatchlistEntryAdded {
-                    user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                    movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
-                    movie_title,
-                    release_year,
-                    external_metadata_id,
-                    added_at: parse_ts(added_at)?,
+                Ok(DomainEvent::MovieDeleted {
+                    movie_id,
+                    poster_path,
                 })
             }
+            EventPayload::UserUpdated { user_id } => Ok(DomainEvent::UserUpdated {
+                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
+            }),
+            EventPayload::ReviewDeleted { review_id, user_id } => Ok(DomainEvent::ReviewDeleted {
+                review_id: ReviewId::from_uuid(parse_uuid(&review_id, "review_id")?),
+                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
+            }),
+            EventPayload::MovieEnrichmentRequested {
+                movie_id,
+                external_metadata_id,
+            } => Ok(DomainEvent::MovieEnrichmentRequested {
+                movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
+                external_metadata_id,
+            }),
+            EventPayload::ImageStored { key } => Ok(DomainEvent::ImageStored { key }),
+            EventPayload::WatchlistEntryAdded {
+                user_id,
+                movie_id,
+                movie_title,
+                release_year,
+                external_metadata_id,
+                added_at,
+            } => Ok(DomainEvent::WatchlistEntryAdded {
+                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
+                movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
+                movie_title,
+                release_year,
+                external_metadata_id,
+                added_at: parse_ts(added_at)?,
+            }),
             EventPayload::WatchlistEntryRemoved { user_id, movie_id } => {
                 Ok(DomainEvent::WatchlistEntryRemoved {
                     user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
                     movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
                 })
             }
-            EventPayload::FollowAccepted { local_user_id, remote_actor_url, outbox_url } => {
-                Ok(DomainEvent::FollowAccepted {
-                    local_user_id: UserId::from_uuid(parse_uuid(&local_user_id, "local_user_id")?),
-                    remote_actor_url,
-                    outbox_url,
-                })
-            }
+            EventPayload::FollowAccepted {
+                local_user_id,
+                remote_actor_url,
+                outbox_url,
+            } => Ok(DomainEvent::FollowAccepted {
+                local_user_id: UserId::from_uuid(parse_uuid(&local_user_id, "local_user_id")?),
+                remote_actor_url,
+                outbox_url,
+            }),
         }
     }
 }

crates/adapters/event-payload/src/tests/lib.rs

@@ -1,7 +1,9 @@
 use super::*;
 
 fn fixed_dt() -> NaiveDateTime {
-    chrono::DateTime::from_timestamp(1_700_000_000, 0).unwrap().naive_utc()
+    chrono::DateTime::from_timestamp(1_700_000_000, 0)
+        .unwrap()
+        .naive_utc()
 }
 
 fn review_logged() -> DomainEvent {
@@ -64,14 +66,25 @@ fn serialized_format_is_tagged() {
 
 #[test]
 fn event_type_strings() {
-    assert_eq!(EventPayload::from(&review_logged()).event_type(), "ReviewLogged");
-    assert_eq!(EventPayload::from(&review_updated()).event_type(), "ReviewUpdated");
-    assert_eq!(EventPayload::from(&movie_discovered()).event_type(), "MovieDiscovered");
+    assert_eq!(
+        EventPayload::from(&review_logged()).event_type(),
+        "ReviewLogged"
+    );
+    assert_eq!(
+        EventPayload::from(&review_updated()).event_type(),
+        "ReviewUpdated"
+    );
+    assert_eq!(
+        EventPayload::from(&movie_discovered()).event_type(),
+        "MovieDiscovered"
+    );
 }
 
 #[test]
 fn round_trip_image_stored() {
-    let event = DomainEvent::ImageStored { key: "avatars/abc123".into() };
+    let event = DomainEvent::ImageStored {
+        key: "avatars/abc123".into(),
+    };
     let payload = EventPayload::from(&event);
     let json = serde_json::to_string(&payload).unwrap();
     let back: EventPayload = serde_json::from_str(&json).unwrap();
@@ -81,6 +94,8 @@ fn round_trip_image_stored() {
 
 #[test]
 fn image_stored_event_type() {
-    let payload = EventPayload::from(&DomainEvent::ImageStored { key: "posters/x".into() });
+    let payload = EventPayload::from(&DomainEvent::ImageStored {
+        key: "posters/x".into(),
+    });
     assert_eq!(payload.event_type(), "ImageStored");
 }