Refactor event payload handling across adapters

- Introduced `event-payload` crate to centralize event payload definitions.
- Updated NATS and PostgreSQL adapters to use the new `EventPayload` type.
- Removed redundant event payload definitions and conversion implementations from NATS and PostgreSQL adapters.
- Simplified SQLite event queue to utilize the new `EventPayload`.
- Refactored wiring functions for PostgreSQL and SQLite to improve database connection handling and migration.
- Cleaned up presentation and worker crates by removing unused event publisher dependencies and related wiring functions.

crates/adapters/event-payload/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "event-payload"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+domain   = { workspace = true }
+serde    = { workspace = true }
+chrono   = { workspace = true }
+uuid     = { workspace = true }
+anyhow   = { workspace = true }

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

@@ -0,0 +1,189 @@
+use chrono::NaiveDateTime;
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    value_objects::{ExternalMetadataId, MovieId, Rating, ReviewId, UserId},
+};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(tag = "type", content = "data")]
+pub enum EventPayload {
+    ReviewLogged {
+        review_id: String,
+        movie_id: String,
+        user_id: String,
+        rating: u8,
+        watched_at: i64,
+    },
+    ReviewUpdated {
+        review_id: String,
+        movie_id: String,
+        user_id: String,
+        rating: u8,
+        watched_at: i64,
+    },
+    MovieDiscovered {
+        movie_id: String,
+        external_metadata_id: String,
+    },
+}
+
+impl EventPayload {
+    pub fn event_type(&self) -> &'static str {
+        match self {
+            EventPayload::ReviewLogged { .. } => "ReviewLogged",
+            EventPayload::ReviewUpdated { .. } => "ReviewUpdated",
+            EventPayload::MovieDiscovered { .. } => "MovieDiscovered",
+        }
+    }
+}
+
+fn parse_uuid(s: &str, field: &str) -> Result<Uuid, DomainError> {
+    Uuid::parse_str(s)
+        .map_err(|e| DomainError::InfrastructureError(format!("{field}: {e}")))
+}
+
+fn parse_ts(ts: i64) -> Result<NaiveDateTime, DomainError> {
+    chrono::DateTime::from_timestamp(ts, 0)
+        .map(|dt| dt.naive_utc())
+        .ok_or_else(|| DomainError::InfrastructureError(format!("invalid timestamp: {ts}")))
+}
+
+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(),
+                }
+            }
+        }
+    }
+}
+
+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)?,
+                })
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn fixed_dt() -> NaiveDateTime {
+        chrono::DateTime::from_timestamp(1_700_000_000, 0).unwrap().naive_utc()
+    }
+
+    fn review_logged() -> DomainEvent {
+        DomainEvent::ReviewLogged {
+            review_id: ReviewId::from_uuid(Uuid::new_v4()),
+            movie_id: MovieId::from_uuid(Uuid::new_v4()),
+            user_id: UserId::from_uuid(Uuid::new_v4()),
+            rating: Rating::new(4).unwrap(),
+            watched_at: fixed_dt(),
+        }
+    }
+
+    fn review_updated() -> DomainEvent {
+        DomainEvent::ReviewUpdated {
+            review_id: ReviewId::from_uuid(Uuid::new_v4()),
+            movie_id: MovieId::from_uuid(Uuid::new_v4()),
+            user_id: UserId::from_uuid(Uuid::new_v4()),
+            rating: Rating::new(3).unwrap(),
+            watched_at: fixed_dt(),
+        }
+    }
+
+    fn movie_discovered() -> DomainEvent {
+        DomainEvent::MovieDiscovered {
+            movie_id: MovieId::from_uuid(Uuid::new_v4()),
+            external_metadata_id: ExternalMetadataId::new("tt1234567".into()).unwrap(),
+        }
+    }
+
+    fn round_trip(event: DomainEvent) {
+        let payload = EventPayload::from(&event);
+        let json = serde_json::to_string(&payload).expect("serialize");
+        let back: EventPayload = serde_json::from_str(&json).expect("deserialize");
+        let recovered = DomainEvent::try_from(back).expect("try_from");
+        assert_eq!(EventPayload::from(&event), EventPayload::from(&recovered));
+    }
+
+    #[test]
+    fn round_trip_review_logged() {
+        round_trip(review_logged());
+    }
+
+    #[test]
+    fn round_trip_review_updated() {
+        round_trip(review_updated());
+    }
+
+    #[test]
+    fn round_trip_movie_discovered() {
+        round_trip(movie_discovered());
+    }
+
+    #[test]
+    fn serialized_format_is_tagged() {
+        let payload = EventPayload::from(&movie_discovered());
+        let json = serde_json::to_string(&payload).unwrap();
+        assert!(json.contains(r#""type":"MovieDiscovered""#));
+        assert!(json.contains(r#""data":"#));
+    }
+
+    #[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");
+    }
+}

crates/adapters/nats/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2024"
 async-nats = "0.48.0"
 
 domain = { workspace = true }
+event-payload = { workspace = true }
 async-trait = { workspace = true }
 anyhow = { workspace = true }
 thiserror = { workspace = true }

crates/adapters/nats/src/payload.rs

@@ -1,172 +1 @@
-use chrono::NaiveDateTime;
-use domain::{
-    errors::DomainError,
-    events::DomainEvent,
-    value_objects::{ExternalMetadataId, MovieId, Rating, ReviewId, UserId},
-};
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(tag = "type", content = "data")]
-pub enum NatsEventPayload {
-    ReviewLogged {
-        review_id: String,
-        movie_id: String,
-        user_id: String,
-        rating: u8,
-        watched_at: i64,
-    },
-    ReviewUpdated {
-        review_id: String,
-        movie_id: String,
-        user_id: String,
-        rating: u8,
-        watched_at: i64,
-    },
-    MovieDiscovered {
-        movie_id: String,
-        external_metadata_id: String,
-    },
-}
-
-fn parse_uuid(s: &str, field: &str) -> Result<Uuid, DomainError> {
-    Uuid::parse_str(s)
-        .map_err(|e| DomainError::InfrastructureError(format!("{field}: {e}")))
-}
-
-fn parse_ts(ts: i64) -> Result<NaiveDateTime, DomainError> {
-    chrono::DateTime::from_timestamp(ts, 0)
-        .map(|dt| dt.naive_utc())
-        .ok_or_else(|| DomainError::InfrastructureError(format!("invalid timestamp: {ts}")))
-}
-
-impl From<&DomainEvent> for NatsEventPayload {
-    fn from(event: &DomainEvent) -> Self {
-        match event {
-            DomainEvent::ReviewLogged { review_id, movie_id, user_id, rating, watched_at } => {
-                NatsEventPayload::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 } => {
-                NatsEventPayload::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 } => {
-                NatsEventPayload::MovieDiscovered {
-                    movie_id: movie_id.value().to_string(),
-                    external_metadata_id: external_metadata_id.value().to_owned(),
-                }
-            }
-        }
-    }
-}
-
-impl TryFrom<NatsEventPayload> for DomainEvent {
-    type Error = DomainError;
-    fn try_from(payload: NatsEventPayload) -> Result<Self, DomainError> {
-        match payload {
-            NatsEventPayload::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)?,
-                })
-            }
-            NatsEventPayload::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)?,
-                })
-            }
-            NatsEventPayload::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)?,
-                })
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn fixed_dt() -> NaiveDateTime {
-        chrono::DateTime::from_timestamp(1_700_000_000, 0).unwrap().naive_utc()
-    }
-
-    fn review_logged() -> DomainEvent {
-        DomainEvent::ReviewLogged {
-            review_id: ReviewId::from_uuid(Uuid::new_v4()),
-            movie_id: MovieId::from_uuid(Uuid::new_v4()),
-            user_id: UserId::from_uuid(Uuid::new_v4()),
-            rating: Rating::new(4).unwrap(),
-            watched_at: fixed_dt(),
-        }
-    }
-
-    fn review_updated() -> DomainEvent {
-        DomainEvent::ReviewUpdated {
-            review_id: ReviewId::from_uuid(Uuid::new_v4()),
-            movie_id: MovieId::from_uuid(Uuid::new_v4()),
-            user_id: UserId::from_uuid(Uuid::new_v4()),
-            rating: Rating::new(3).unwrap(),
-            watched_at: fixed_dt(),
-        }
-    }
-
-    fn movie_discovered() -> DomainEvent {
-        DomainEvent::MovieDiscovered {
-            movie_id: MovieId::from_uuid(Uuid::new_v4()),
-            external_metadata_id: ExternalMetadataId::new("tt1234567".into()).unwrap(),
-        }
-    }
-
-    fn round_trip(event: DomainEvent) {
-        let payload = NatsEventPayload::from(&event);
-        let json = serde_json::to_string(&payload).expect("serialize");
-        let back: NatsEventPayload = serde_json::from_str(&json).expect("deserialize");
-        let recovered = DomainEvent::try_from(back).expect("try_from");
-        assert_eq!(NatsEventPayload::from(&event), NatsEventPayload::from(&recovered));
-    }
-
-    #[test]
-    fn round_trip_review_logged() {
-        round_trip(review_logged());
-    }
-
-    #[test]
-    fn round_trip_review_updated() {
-        round_trip(review_updated());
-    }
-
-    #[test]
-    fn round_trip_movie_discovered() {
-        round_trip(movie_discovered());
-    }
-
-    #[test]
-    fn serialized_format_is_tagged() {
-        let payload = NatsEventPayload::from(&movie_discovered());
-        let json = serde_json::to_string(&payload).unwrap();
-        assert!(json.contains(r#""type":"MovieDiscovered""#));
-        assert!(json.contains(r#""data":"#));
-    }
-}
+pub use event_payload::EventPayload as NatsEventPayload;

crates/adapters/postgres-event-queue/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2024"
 [dependencies]
 sqlx        = { version = "0.8.6", features = ["runtime-tokio-rustls", "postgres", "macros", "chrono"] }
 domain      = { workspace = true }
+event-payload = { workspace = true }
 anyhow      = { workspace = true }
 async-trait = { workspace = true }
 serde       = { workspace = true }

crates/adapters/postgres-event-queue/src/payload.rs

@@ -1,189 +1 @@
-use chrono::NaiveDateTime;
-use domain::{
-    errors::DomainError,
-    events::DomainEvent,
-    value_objects::{ExternalMetadataId, MovieId, Rating, ReviewId, UserId},
-};
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(tag = "type", content = "data")]
-pub enum DbEventPayload {
-    ReviewLogged {
-        review_id: String,
-        movie_id: String,
-        user_id: String,
-        rating: u8,
-        watched_at: i64,
-    },
-    ReviewUpdated {
-        review_id: String,
-        movie_id: String,
-        user_id: String,
-        rating: u8,
-        watched_at: i64,
-    },
-    MovieDiscovered {
-        movie_id: String,
-        external_metadata_id: String,
-    },
-}
-
-impl DbEventPayload {
-    pub fn event_type(&self) -> &'static str {
-        match self {
-            DbEventPayload::ReviewLogged { .. } => "ReviewLogged",
-            DbEventPayload::ReviewUpdated { .. } => "ReviewUpdated",
-            DbEventPayload::MovieDiscovered { .. } => "MovieDiscovered",
-        }
-    }
-}
-
-fn parse_uuid(s: &str, field: &str) -> Result<Uuid, DomainError> {
-    Uuid::parse_str(s)
-        .map_err(|e| DomainError::InfrastructureError(format!("{field}: {e}")))
-}
-
-fn parse_ts(ts: i64) -> Result<NaiveDateTime, DomainError> {
-    chrono::DateTime::from_timestamp(ts, 0)
-        .map(|dt| dt.naive_utc())
-        .ok_or_else(|| DomainError::InfrastructureError(format!("invalid timestamp: {ts}")))
-}
-
-impl From<&DomainEvent> for DbEventPayload {
-    fn from(event: &DomainEvent) -> Self {
-        match event {
-            DomainEvent::ReviewLogged { review_id, movie_id, user_id, rating, watched_at } => {
-                DbEventPayload::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 } => {
-                DbEventPayload::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 } => {
-                DbEventPayload::MovieDiscovered {
-                    movie_id: movie_id.value().to_string(),
-                    external_metadata_id: external_metadata_id.value().to_owned(),
-                }
-            }
-        }
-    }
-}
-
-impl TryFrom<DbEventPayload> for DomainEvent {
-    type Error = DomainError;
-    fn try_from(payload: DbEventPayload) -> Result<Self, DomainError> {
-        match payload {
-            DbEventPayload::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)?,
-                })
-            }
-            DbEventPayload::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)?,
-                })
-            }
-            DbEventPayload::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)?,
-                })
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn fixed_dt() -> NaiveDateTime {
-        chrono::DateTime::from_timestamp(1_700_000_000, 0).unwrap().naive_utc()
-    }
-
-    fn review_logged() -> DomainEvent {
-        DomainEvent::ReviewLogged {
-            review_id: ReviewId::from_uuid(Uuid::new_v4()),
-            movie_id: MovieId::from_uuid(Uuid::new_v4()),
-            user_id: UserId::from_uuid(Uuid::new_v4()),
-            rating: Rating::new(4).unwrap(),
-            watched_at: fixed_dt(),
-        }
-    }
-
-    fn review_updated() -> DomainEvent {
-        DomainEvent::ReviewUpdated {
-            review_id: ReviewId::from_uuid(Uuid::new_v4()),
-            movie_id: MovieId::from_uuid(Uuid::new_v4()),
-            user_id: UserId::from_uuid(Uuid::new_v4()),
-            rating: Rating::new(3).unwrap(),
-            watched_at: fixed_dt(),
-        }
-    }
-
-    fn movie_discovered() -> DomainEvent {
-        DomainEvent::MovieDiscovered {
-            movie_id: MovieId::from_uuid(Uuid::new_v4()),
-            external_metadata_id: ExternalMetadataId::new("tt1234567".into()).unwrap(),
-        }
-    }
-
-    fn round_trip(event: DomainEvent) {
-        let payload = DbEventPayload::from(&event);
-        let json = serde_json::to_string(&payload).expect("serialize");
-        let back: DbEventPayload = serde_json::from_str(&json).expect("deserialize");
-        let recovered = DomainEvent::try_from(back).expect("try_from");
-        assert_eq!(DbEventPayload::from(&event), DbEventPayload::from(&recovered));
-    }
-
-    #[test]
-    fn round_trip_review_logged() {
-        round_trip(review_logged());
-    }
-
-    #[test]
-    fn round_trip_review_updated() {
-        round_trip(review_updated());
-    }
-
-    #[test]
-    fn round_trip_movie_discovered() {
-        round_trip(movie_discovered());
-    }
-
-    #[test]
-    fn serialized_format_is_tagged() {
-        let payload = DbEventPayload::from(&movie_discovered());
-        let json = serde_json::to_string(&payload).unwrap();
-        assert!(json.contains(r#""type":"MovieDiscovered""#));
-        assert!(json.contains(r#""data":"#));
-    }
-
-    #[test]
-    fn event_type_strings() {
-        assert_eq!(DbEventPayload::from(&review_logged()).event_type(), "ReviewLogged");
-        assert_eq!(DbEventPayload::from(&review_updated()).event_type(), "ReviewUpdated");
-        assert_eq!(DbEventPayload::from(&movie_discovered()).event_type(), "MovieDiscovered");
-    }
-}
+pub use event_payload::EventPayload as DbEventPayload;

crates/adapters/postgres/Cargo.toml

@@ -12,6 +12,7 @@ sqlx = { version = "0.8.6", features = [
     "chrono",
 ] }
 domain      = { workspace = true }
+anyhow      = { workspace = true }
 uuid        = { workspace = true }
 chrono      = { workspace = true }
 tracing     = { workspace = true }

crates/adapters/postgres/src/lib.rs

@@ -767,3 +767,33 @@ impl StatsRepository for PostgresRepository {
         })
     }
 }
+
+pub async fn wire(database_url: &str) -> anyhow::Result<(
+    sqlx::PgPool,
+    std::sync::Arc<dyn domain::ports::MovieRepository>,
+    std::sync::Arc<dyn domain::ports::ReviewRepository>,
+    std::sync::Arc<dyn domain::ports::DiaryRepository>,
+    std::sync::Arc<dyn domain::ports::StatsRepository>,
+    std::sync::Arc<dyn domain::ports::UserRepository>,
+)> {
+    use anyhow::Context;
+
+    let pool = sqlx::PgPool::connect(database_url)
+        .await
+        .context("Failed to connect to PostgreSQL database")?;
+
+    let repo = std::sync::Arc::new(PostgresRepository::new(pool.clone()));
+    repo.migrate()
+        .await
+        .map_err(|e| anyhow::anyhow!("{e}"))
+        .context("Database migration failed")?;
+
+    Ok((
+        pool.clone(),
+        std::sync::Arc::clone(&repo) as _,
+        std::sync::Arc::clone(&repo) as _,
+        std::sync::Arc::clone(&repo) as _,
+        std::sync::Arc::clone(&repo) as _,
+        std::sync::Arc::new(PostgresUserRepository::new(pool)) as _,
+    ))
+}

crates/adapters/sqlite-event-queue/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2024"
 [dependencies]
 sqlx        = { version = "0.8.6", features = ["runtime-tokio-rustls", "sqlite", "macros", "chrono"] }
 domain      = { workspace = true }
+event-payload = { workspace = true }
 anyhow      = { workspace = true }
 async-trait = { workspace = true }
 serde       = { workspace = true }

crates/adapters/sqlite-event-queue/src/payload.rs

@@ -1,189 +1 @@
-use chrono::NaiveDateTime;
-use domain::{
-    errors::DomainError,
-    events::DomainEvent,
-    value_objects::{ExternalMetadataId, MovieId, Rating, ReviewId, UserId},
-};
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(tag = "type", content = "data")]
-pub enum DbEventPayload {
-    ReviewLogged {
-        review_id: String,
-        movie_id: String,
-        user_id: String,
-        rating: u8,
-        watched_at: i64,
-    },
-    ReviewUpdated {
-        review_id: String,
-        movie_id: String,
-        user_id: String,
-        rating: u8,
-        watched_at: i64,
-    },
-    MovieDiscovered {
-        movie_id: String,
-        external_metadata_id: String,
-    },
-}
-
-impl DbEventPayload {
-    pub fn event_type(&self) -> &'static str {
-        match self {
-            DbEventPayload::ReviewLogged { .. } => "ReviewLogged",
-            DbEventPayload::ReviewUpdated { .. } => "ReviewUpdated",
-            DbEventPayload::MovieDiscovered { .. } => "MovieDiscovered",
-        }
-    }
-}
-
-fn parse_uuid(s: &str, field: &str) -> Result<Uuid, DomainError> {
-    Uuid::parse_str(s)
-        .map_err(|e| DomainError::InfrastructureError(format!("{field}: {e}")))
-}
-
-fn parse_ts(ts: i64) -> Result<NaiveDateTime, DomainError> {
-    chrono::DateTime::from_timestamp(ts, 0)
-        .map(|dt| dt.naive_utc())
-        .ok_or_else(|| DomainError::InfrastructureError(format!("invalid timestamp: {ts}")))
-}
-
-impl From<&DomainEvent> for DbEventPayload {
-    fn from(event: &DomainEvent) -> Self {
-        match event {
-            DomainEvent::ReviewLogged { review_id, movie_id, user_id, rating, watched_at } => {
-                DbEventPayload::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 } => {
-                DbEventPayload::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 } => {
-                DbEventPayload::MovieDiscovered {
-                    movie_id: movie_id.value().to_string(),
-                    external_metadata_id: external_metadata_id.value().to_owned(),
-                }
-            }
-        }
-    }
-}
-
-impl TryFrom<DbEventPayload> for DomainEvent {
-    type Error = DomainError;
-    fn try_from(payload: DbEventPayload) -> Result<Self, DomainError> {
-        match payload {
-            DbEventPayload::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)?,
-                })
-            }
-            DbEventPayload::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)?,
-                })
-            }
-            DbEventPayload::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)?,
-                })
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn fixed_dt() -> NaiveDateTime {
-        chrono::DateTime::from_timestamp(1_700_000_000, 0).unwrap().naive_utc()
-    }
-
-    fn review_logged() -> DomainEvent {
-        DomainEvent::ReviewLogged {
-            review_id: ReviewId::from_uuid(Uuid::new_v4()),
-            movie_id: MovieId::from_uuid(Uuid::new_v4()),
-            user_id: UserId::from_uuid(Uuid::new_v4()),
-            rating: Rating::new(4).unwrap(),
-            watched_at: fixed_dt(),
-        }
-    }
-
-    fn review_updated() -> DomainEvent {
-        DomainEvent::ReviewUpdated {
-            review_id: ReviewId::from_uuid(Uuid::new_v4()),
-            movie_id: MovieId::from_uuid(Uuid::new_v4()),
-            user_id: UserId::from_uuid(Uuid::new_v4()),
-            rating: Rating::new(3).unwrap(),
-            watched_at: fixed_dt(),
-        }
-    }
-
-    fn movie_discovered() -> DomainEvent {
-        DomainEvent::MovieDiscovered {
-            movie_id: MovieId::from_uuid(Uuid::new_v4()),
-            external_metadata_id: ExternalMetadataId::new("tt1234567".into()).unwrap(),
-        }
-    }
-
-    fn round_trip(event: DomainEvent) {
-        let payload = DbEventPayload::from(&event);
-        let json = serde_json::to_string(&payload).expect("serialize");
-        let back: DbEventPayload = serde_json::from_str(&json).expect("deserialize");
-        let recovered = DomainEvent::try_from(back).expect("try_from");
-        assert_eq!(DbEventPayload::from(&event), DbEventPayload::from(&recovered));
-    }
-
-    #[test]
-    fn round_trip_review_logged() {
-        round_trip(review_logged());
-    }
-
-    #[test]
-    fn round_trip_review_updated() {
-        round_trip(review_updated());
-    }
-
-    #[test]
-    fn round_trip_movie_discovered() {
-        round_trip(movie_discovered());
-    }
-
-    #[test]
-    fn serialized_format_is_tagged() {
-        let payload = DbEventPayload::from(&movie_discovered());
-        let json = serde_json::to_string(&payload).unwrap();
-        assert!(json.contains(r#""type":"MovieDiscovered""#));
-        assert!(json.contains(r#""data":"#));
-    }
-
-    #[test]
-    fn event_type_strings() {
-        assert_eq!(DbEventPayload::from(&review_logged()).event_type(), "ReviewLogged");
-        assert_eq!(DbEventPayload::from(&review_updated()).event_type(), "ReviewUpdated");
-        assert_eq!(DbEventPayload::from(&movie_discovered()).event_type(), "MovieDiscovered");
-    }
-}
+pub use event_payload::EventPayload as DbEventPayload;

crates/adapters/sqlite/src/lib.rs

@@ -759,6 +759,43 @@ impl StatsRepository for SqliteMovieRepository {
     }
 }
 
+pub async fn wire(database_url: &str) -> anyhow::Result<(
+    sqlx::SqlitePool,
+    std::sync::Arc<dyn domain::ports::MovieRepository>,
+    std::sync::Arc<dyn domain::ports::ReviewRepository>,
+    std::sync::Arc<dyn domain::ports::DiaryRepository>,
+    std::sync::Arc<dyn domain::ports::StatsRepository>,
+    std::sync::Arc<dyn domain::ports::UserRepository>,
+)> {
+    use std::str::FromStr;
+    use anyhow::Context;
+    use sqlx::sqlite::SqliteConnectOptions;
+
+    let opts = SqliteConnectOptions::from_str(database_url)
+        .context("Invalid DATABASE_URL")?
+        .create_if_missing(true)
+        .journal_mode(sqlx::sqlite::SqliteJournalMode::Wal)
+        .busy_timeout(std::time::Duration::from_secs(5));
+    let pool = sqlx::SqlitePool::connect_with(opts)
+        .await
+        .context("Failed to connect to SQLite database")?;
+
+    let repo = std::sync::Arc::new(SqliteMovieRepository::new(pool.clone()));
+    repo.migrate()
+        .await
+        .map_err(|e| anyhow::anyhow!("{e}"))
+        .context("Database migration failed")?;
+
+    Ok((
+        pool.clone(),
+        std::sync::Arc::clone(&repo) as _,
+        std::sync::Arc::clone(&repo) as _,
+        std::sync::Arc::clone(&repo) as _,
+        std::sync::Arc::clone(&repo) as _,
+        std::sync::Arc::new(SqliteUserRepository::new(pool)) as _,
+    ))
+}
+
 #[cfg(test)]
 mod feed_filter_tests {
     use super::*;