fmt

crates/worker/src/db.rs

@@ -26,45 +26,78 @@ pub struct Repos {
     pub movie_profile: Arc<dyn MovieProfileRepository>,
     pub watchlist: Arc<dyn WatchlistRepository>,
     pub image_ref_command: Arc<dyn ImageRefCommand>,
-    pub image_ref_query:   Arc<dyn ImageRefQuery>,
-    pub person_command:    Arc<dyn PersonCommand>,
-    pub person_query:      Arc<dyn PersonQuery>,
-    pub search_command:    Arc<dyn SearchCommand>,
-    pub search_port:       Arc<dyn SearchPort>,
-    pub profile_fields:    Arc<dyn UserProfileFieldsRepository>,
+    pub image_ref_query: Arc<dyn ImageRefQuery>,
+    pub person_command: Arc<dyn PersonCommand>,
+    pub person_query: Arc<dyn PersonQuery>,
+    pub search_command: Arc<dyn SearchCommand>,
+    pub search_port: Arc<dyn SearchPort>,
+    pub profile_fields: Arc<dyn UserProfileFieldsRepository>,
 }
 
 pub async fn connect(database_url: &str, backend: &str) -> anyhow::Result<(Repos, DbPool)> {
     match backend {
         #[cfg(feature = "postgres")]
         "postgres" => {
-            let (pool, m, r, d, s, u, is, ip, mp, wl) =
-                postgres::wire(database_url).await.context("PostgreSQL connection failed")?;
+            let (pool, m, r, d, s, u, is, ip, mp, wl) = postgres::wire(database_url)
+                .await
+                .context("PostgreSQL connection failed")?;
             let (image_ref_command, image_ref_query) = postgres::create_image_ref(pool.clone());
             let (person_command, person_query) = postgres::create_person_adapter(pool.clone());
-            let (search_command, search_port)  = postgres_search::create_search_adapter(pool.clone());
+            let (search_command, search_port) =
+                postgres_search::create_search_adapter(pool.clone());
             let pf = postgres::create_profile_fields_repo(pool.clone());
-            Ok((Repos { movie: m, review: r, diary: d, stats: s, user: u,
-                        import_session: is, import_profile: ip, movie_profile: mp, watchlist: wl,
-                        image_ref_command, image_ref_query,
-                        person_command, person_query, search_command, search_port,
-                        profile_fields: pf },
-                DbPool::Postgres(pool)))
+            Ok((
+                Repos {
+                    movie: m,
+                    review: r,
+                    diary: d,
+                    stats: s,
+                    user: u,
+                    import_session: is,
+                    import_profile: ip,
+                    movie_profile: mp,
+                    watchlist: wl,
+                    image_ref_command,
+                    image_ref_query,
+                    person_command,
+                    person_query,
+                    search_command,
+                    search_port,
+                    profile_fields: pf,
+                },
+                DbPool::Postgres(pool),
+            ))
         }
         #[cfg(feature = "sqlite")]
         _ => {
-            let (pool, m, r, d, s, u, is, ip, mp, wl) =
-                sqlite::wire(database_url).await.context("SQLite connection failed")?;
+            let (pool, m, r, d, s, u, is, ip, mp, wl) = sqlite::wire(database_url)
+                .await
+                .context("SQLite connection failed")?;
             let (image_ref_command, image_ref_query) = sqlite::create_image_ref(pool.clone());
             let (person_command, person_query) = sqlite::create_person_adapter(pool.clone());
-            let (search_command, search_port)  = sqlite_search::create_search_adapter(pool.clone());
+            let (search_command, search_port) = sqlite_search::create_search_adapter(pool.clone());
             let pf = sqlite::create_profile_fields_repo(pool.clone());
-            Ok((Repos { movie: m, review: r, diary: d, stats: s, user: u,
-                        import_session: is, import_profile: ip, movie_profile: mp, watchlist: wl,
-                        image_ref_command, image_ref_query,
-                        person_command, person_query, search_command, search_port,
-                        profile_fields: pf },
-                DbPool::Sqlite(pool)))
+            Ok((
+                Repos {
+                    movie: m,
+                    review: r,
+                    diary: d,
+                    stats: s,
+                    user: u,
+                    import_session: is,
+                    import_profile: ip,
+                    movie_profile: mp,
+                    watchlist: wl,
+                    image_ref_command,
+                    image_ref_query,
+                    person_command,
+                    person_query,
+                    search_command,
+                    search_port,
+                    profile_fields: pf,
+                },
+                DbPool::Sqlite(pool),
+            ))
         }
         #[cfg(not(feature = "sqlite"))]
         _ => anyhow::bail!("DATABASE_BACKEND={backend} is not supported by this build"),

crates/worker/src/event_bus.rs

@@ -23,9 +23,9 @@ impl EventBusBackend {
             #[cfg(feature = "nats")]
             "nats" => Ok(Self::Nats),
             #[cfg(not(feature = "nats"))]
-            "nats" => anyhow::bail!(
-                "EVENT_BUS_BACKEND=nats requires the nats feature to be compiled in"
-            ),
+            "nats" => {
+                anyhow::bail!("EVENT_BUS_BACKEND=nats requires the nats feature to be compiled in")
+            }
             other => anyhow::bail!("unknown EVENT_BUS_BACKEND={other}, expected 'db' or 'nats'"),
         }
     }
@@ -39,9 +39,9 @@ pub async fn create(
             tracing::info!("event bus: DB queue");
             match db_pool {
                 #[cfg(feature = "postgres")]
-                DbPool::Postgres(pool) => {
-                    Ok(postgres_event_queue::PostgresEventQueue::create_channel(pool.clone()).await?)
-                }
+                DbPool::Postgres(pool) => Ok(
+                    postgres_event_queue::PostgresEventQueue::create_channel(pool.clone()).await?,
+                ),
                 #[cfg(feature = "sqlite")]
                 DbPool::Sqlite(pool) => {
                     Ok(sqlite_event_queue::SqliteEventQueue::create_channel(pool.clone()).await?)

crates/worker/src/follow_backfill_handler.rs

@@ -10,7 +10,12 @@ pub struct FollowBackfillHandler {
 #[async_trait]
 impl EventHandler for FollowBackfillHandler {
     async fn handle(&self, event: &DomainEvent) -> Result<(), DomainError> {
-        let DomainEvent::FollowAccepted { remote_actor_url, outbox_url, .. } = event else {
+        let DomainEvent::FollowAccepted {
+            remote_actor_url,
+            outbox_url,
+            ..
+        } = event
+        else {
             return Ok(());
         };
         tracing::info!(actor = %remote_actor_url, outbox = %outbox_url, "starting outbox backfill");

crates/worker/src/main.rs

@@ -5,7 +5,10 @@ mod follow_backfill_handler;
 use std::sync::Arc;
 
 use anyhow::Context;
-use application::{config::AppConfig, context::AppContext, worker::WorkerService, MovieDiscoveryIndexer, SearchCleanupHandler};
+use application::{
+    MovieDiscoveryIndexer, SearchCleanupHandler, config::AppConfig, context::AppContext,
+    worker::WorkerService,
+};
 use export::ExportAdapter;
 use importer::ImporterDocumentParser;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
@@ -13,7 +16,9 @@ use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 use domain::ports::{DiaryExporter, DocumentParser, EventHandler, PeriodicJob};
 
 #[cfg(not(any(feature = "sqlite", feature = "postgres")))]
-compile_error!("At least one database backend must be enabled. Use --features sqlite or --features postgres");
+compile_error!(
+    "At least one database backend must be enabled. Use --features sqlite or --features postgres"
+);
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
@@ -32,17 +37,24 @@ async fn main() -> anyhow::Result<()> {
     let (repos, db_pool) = db::connect(&database_url, &backend).await?;
     let (event_publisher_arc, consumer_arc) = event_bus::create(&db_pool).await?;
 
-    let image_ref_command   = Arc::clone(&repos.image_ref_command);
-    let image_ref_query     = Arc::clone(&repos.image_ref_query);
-    let person_command      = Arc::clone(&repos.person_command);
-    let person_query        = Arc::clone(&repos.person_query);
-    let search_command      = Arc::clone(&repos.search_command);
-    let search_port         = Arc::clone(&repos.search_port);
+    let image_ref_command = Arc::clone(&repos.image_ref_command);
+    let image_ref_query = Arc::clone(&repos.image_ref_query);
+    let person_command = Arc::clone(&repos.person_command);
+    let person_query = Arc::clone(&repos.person_query);
+    let search_command = Arc::clone(&repos.search_command);
+    let search_port = Arc::clone(&repos.search_port);
     let profile_fields_repo = Arc::clone(&repos.profile_fields);
 
     // Clone refs federation handler needs before ctx consumes them.
     #[cfg(feature = "federation")]
-    let (fed_movie_repo, fed_review_repo, fed_diary_repo, fed_user_repo, base_url, allow_registration) = (
+    let (
+        fed_movie_repo,
+        fed_review_repo,
+        fed_diary_repo,
+        fed_user_repo,
+        base_url,
+        allow_registration,
+    ) = (
         Arc::clone(&repos.movie),
         Arc::clone(&repos.review),
         Arc::clone(&repos.diary),
@@ -52,38 +64,39 @@ async fn main() -> anyhow::Result<()> {
     );
     // Wire federation repos early to get remote_watchlist_repo for AppContext.
     #[cfg(feature = "federation")]
-    let (fed_federation_repo, _fed_social_query, fed_review_store, fed_remote_watchlist_repo) = match &db_pool {
-        #[cfg(feature = "sqlite-federation")]
-        db::DbPool::Sqlite(pool) => sqlite_federation::wire(pool.clone()),
-        #[cfg(feature = "postgres-federation")]
-        db::DbPool::Postgres(pool) => postgres_federation::wire(pool.clone()),
-    };
+    let (fed_federation_repo, _fed_social_query, fed_review_store, fed_remote_watchlist_repo) =
+        match &db_pool {
+            #[cfg(feature = "sqlite-federation")]
+            db::DbPool::Sqlite(pool) => sqlite_federation::wire(pool.clone()),
+            #[cfg(feature = "postgres-federation")]
+            db::DbPool::Postgres(pool) => postgres_federation::wire(pool.clone()),
+        };
 
     let ctx = AppContext {
-        movie_repository:       repos.movie,
-        review_repository:      repos.review,
-        diary_repository:       repos.diary,
-        diary_exporter:         Arc::new(ExportAdapter) as Arc<dyn DiaryExporter>,
-        document_parser:        Arc::new(ImporterDocumentParser) as Arc<dyn DocumentParser>,
-        stats_repository:       repos.stats,
+        movie_repository: repos.movie,
+        review_repository: repos.review,
+        diary_repository: repos.diary,
+        diary_exporter: Arc::new(ExportAdapter) as Arc<dyn DiaryExporter>,
+        document_parser: Arc::new(ImporterDocumentParser) as Arc<dyn DocumentParser>,
+        stats_repository: repos.stats,
         metadata_client,
         poster_fetcher,
         image_storage,
-        event_publisher:        event_publisher_arc,
+        event_publisher: event_publisher_arc,
         auth_service,
         password_hasher,
-        user_repository:        repos.user,
+        user_repository: repos.user,
         import_session_repository: repos.import_session,
         import_profile_repository: repos.import_profile,
-        movie_profile_repository:  repos.movie_profile,
-        watchlist_repository:      repos.watchlist,
+        movie_profile_repository: repos.movie_profile,
+        watchlist_repository: repos.watchlist,
         profile_fields_repository: Arc::clone(&profile_fields_repo),
         #[cfg(feature = "federation")]
         remote_watchlist_repository: fed_remote_watchlist_repo.clone(),
-        person_command:            Arc::clone(&person_command),
-        person_query:              Arc::clone(&person_query),
-        search_port:               Arc::clone(&search_port),
-        search_command:            Arc::clone(&search_command),
+        person_command: Arc::clone(&person_command),
+        person_query: Arc::clone(&person_query),
+        search_port: Arc::clone(&search_port),
+        search_command: Arc::clone(&search_command),
         config: app_config,
     };
 
@@ -91,26 +104,28 @@ async fn main() -> anyhow::Result<()> {
     // Both the event handler and the staleness job are gated on TMDB_API_KEY.
     // Without a key, no MovieEnrichmentRequested events are produced or handled.
 
-    let (enrichment_handler, enrichment_job): (Option<Arc<dyn EventHandler>>, Option<Arc<dyn PeriodicJob>>) =
-        match tmdb_enrichment::TmdbEnrichmentClient::from_env() {
-            Ok(client) => {
-                tracing::info!("TMDb enrichment enabled");
-                let handler = Arc::new(tmdb_enrichment::EnrichmentHandler {
-                    enrichment_client: Arc::new(client),
-                    movie_repository:  Arc::clone(&ctx.movie_repository),
-                    profile_repo:      Arc::clone(&ctx.movie_profile_repository),
-                    person_command:    Arc::clone(&ctx.person_command),
-                    search_command:    Arc::clone(&ctx.search_command),
-                }) as Arc<dyn EventHandler>;
-                let job = Arc::new(application::jobs::EnrichmentStalenessJob::new(ctx.clone()))
-                    as Arc<dyn PeriodicJob>;
-                (Some(handler), Some(job))
-            }
-            Err(e) => {
-                tracing::warn!("TMDb enrichment disabled: {e}");
-                (None, None)
-            }
-        };
+    let (enrichment_handler, enrichment_job): (
+        Option<Arc<dyn EventHandler>>,
+        Option<Arc<dyn PeriodicJob>>,
+    ) = match tmdb_enrichment::TmdbEnrichmentClient::from_env() {
+        Ok(client) => {
+            tracing::info!("TMDb enrichment enabled");
+            let handler = Arc::new(tmdb_enrichment::EnrichmentHandler {
+                enrichment_client: Arc::new(client),
+                movie_repository: Arc::clone(&ctx.movie_repository),
+                profile_repo: Arc::clone(&ctx.movie_profile_repository),
+                person_command: Arc::clone(&ctx.person_command),
+                search_command: Arc::clone(&ctx.search_command),
+            }) as Arc<dyn EventHandler>;
+            let job = Arc::new(application::jobs::EnrichmentStalenessJob::new(ctx.clone()))
+                as Arc<dyn PeriodicJob>;
+            (Some(handler), Some(job))
+        }
+        Err(e) => {
+            tracing::warn!("TMDb enrichment disabled: {e}");
+            (None, None)
+        }
+    };
 
     // ── Image conversion ──────────────────────────────────────────────────────
 
@@ -123,11 +138,15 @@ async fn main() -> anyhow::Result<()> {
 
     // ── Periodic jobs ─────────────────────────────────────────────────────────
 
-    let mut periodic_jobs: Vec<Arc<dyn PeriodicJob>> = vec![
-        Arc::new(application::jobs::ImportSessionCleanupJob::new(ctx.clone())),
-    ];
-    if let Some(job) = enrichment_job { periodic_jobs.push(job); }
-    if let Some((_, ref conv_job)) = conversion { periodic_jobs.push(Arc::clone(conv_job)); }
+    let mut periodic_jobs: Vec<Arc<dyn PeriodicJob>> = vec![Arc::new(
+        application::jobs::ImportSessionCleanupJob::new(ctx.clone()),
+    )];
+    if let Some(job) = enrichment_job {
+        periodic_jobs.push(job);
+    }
+    if let Some((_, ref conv_job)) = conversion {
+        periodic_jobs.push(Arc::clone(conv_job));
+    }
 
     for job in periodic_jobs {
         tokio::spawn(async move {
@@ -153,17 +172,27 @@ async fn main() -> anyhow::Result<()> {
             3,
         )) as Arc<dyn EventHandler>;
 
-        let cleanup = Arc::new(image_storage::ImageCleanupHandler::new(
-            Arc::clone(&ctx.image_storage),
-        )) as Arc<dyn EventHandler>;
+        let cleanup = Arc::new(image_storage::ImageCleanupHandler::new(Arc::clone(
+            &ctx.image_storage,
+        ))) as Arc<dyn EventHandler>;
 
         #[cfg(not(feature = "federation"))]
         {
-            let search_cleanup = Arc::new(SearchCleanupHandler::new(Arc::clone(&ctx.search_command), Arc::clone(&ctx.person_query))) as Arc<dyn EventHandler>;
-            let discovery_indexer = Arc::new(MovieDiscoveryIndexer::new(Arc::clone(&ctx.movie_repository), Arc::clone(&ctx.search_command))) as Arc<dyn EventHandler>;
+            let search_cleanup = Arc::new(SearchCleanupHandler::new(
+                Arc::clone(&ctx.search_command),
+                Arc::clone(&ctx.person_query),
+            )) as Arc<dyn EventHandler>;
+            let discovery_indexer = Arc::new(MovieDiscoveryIndexer::new(
+                Arc::clone(&ctx.movie_repository),
+                Arc::clone(&ctx.search_command),
+            )) as Arc<dyn EventHandler>;
             let mut h = vec![poster, cleanup, search_cleanup, discovery_indexer];
-            if let Some(e) = enrichment_handler { h.push(e); }
-            if let Some((ref conv_handler, _)) = conversion { h.push(Arc::clone(conv_handler)); }
+            if let Some(e) = enrichment_handler {
+                h.push(e);
+            }
+            if let Some((ref conv_handler, _)) = conversion {
+                h.push(Arc::clone(conv_handler));
+            }
             h
         }
 
@@ -180,19 +209,37 @@ async fn main() -> anyhow::Result<()> {
                 base_url,
                 allow_registration,
                 Arc::clone(&ctx.event_publisher),
-            ).await?;
+            )
+            .await?;
 
             let ap_event_handler = ap_wire.event_handler;
             let backfill = Arc::new(follow_backfill_handler::FollowBackfillHandler {
                 ap_service: ap_wire.service,
             }) as Arc<dyn EventHandler>;
 
-            let search_cleanup = Arc::new(SearchCleanupHandler::new(Arc::clone(&ctx.search_command), Arc::clone(&ctx.person_query))) as Arc<dyn EventHandler>;
-            let discovery_indexer = Arc::new(MovieDiscoveryIndexer::new(Arc::clone(&ctx.movie_repository), Arc::clone(&ctx.search_command))) as Arc<dyn EventHandler>;
+            let search_cleanup = Arc::new(SearchCleanupHandler::new(
+                Arc::clone(&ctx.search_command),
+                Arc::clone(&ctx.person_query),
+            )) as Arc<dyn EventHandler>;
+            let discovery_indexer = Arc::new(MovieDiscoveryIndexer::new(
+                Arc::clone(&ctx.movie_repository),
+                Arc::clone(&ctx.search_command),
+            )) as Arc<dyn EventHandler>;
             tracing::info!("federation event handler registered");
-            let mut h = vec![poster, cleanup, ap_event_handler, backfill, search_cleanup, discovery_indexer];
-            if let Some(e) = enrichment_handler { h.push(e); }
-            if let Some((ref conv_handler, _)) = conversion { h.push(Arc::clone(conv_handler)); }
+            let mut h = vec![
+                poster,
+                cleanup,
+                ap_event_handler,
+                backfill,
+                search_cleanup,
+                discovery_indexer,
+            ];
+            if let Some(e) = enrichment_handler {
+                h.push(e);
+            }
+            if let Some((ref conv_handler, _)) = conversion {
+                h.push(Arc::clone(conv_handler));
+            }
             h
         }
     };