refactor: split jobs.rs into per-context modules

crates/application/src/jobs/enrichment_staleness.rs

@@ -0,0 +1,39 @@
+use std::time::Duration;
+
+use async_trait::async_trait;
+use domain::{errors::DomainError, events::DomainEvent, ports::PeriodicJob};
+
+use crate::context::AppContext;
+
+pub struct EnrichmentStalenessJob {
+    ctx: AppContext,
+}
+
+impl EnrichmentStalenessJob {
+    pub fn new(ctx: AppContext) -> Self {
+        Self { ctx }
+    }
+}
+
+#[async_trait]
+impl PeriodicJob for EnrichmentStalenessJob {
+    fn interval(&self) -> Duration {
+        Duration::from_secs(3600)
+    }
+
+    async fn run(&self) -> Result<(), DomainError> {
+        let stale = self.ctx.repos.movie_profile.list_stale().await?;
+        if stale.is_empty() {
+            return Ok(());
+        }
+        tracing::info!("enrichment scan: {} stale movies", stale.len());
+        for (movie_id, external_metadata_id) in stale {
+            let event = DomainEvent::MovieEnrichmentRequested {
+                movie_id,
+                external_metadata_id,
+            };
+            self.ctx.services.event_publisher.publish(&event).await?;
+        }
+        Ok(())
+    }
+}

crates/application/src/jobs/import_cleanup.rs

@@ -0,0 +1,29 @@
+use std::time::Duration;
+
+use async_trait::async_trait;
+use domain::{errors::DomainError, ports::PeriodicJob};
+
+use crate::context::AppContext;
+
+pub struct ImportSessionCleanupJob {
+    ctx: AppContext,
+}
+
+impl ImportSessionCleanupJob {
+    pub fn new(ctx: AppContext) -> Self {
+        Self { ctx }
+    }
+}
+
+#[async_trait]
+impl PeriodicJob for ImportSessionCleanupJob {
+    fn interval(&self) -> Duration {
+        Duration::from_secs(3600)
+    }
+
+    async fn run(&self) -> Result<(), DomainError> {
+        let n = crate::import::cleanup::execute(&self.ctx).await?;
+        tracing::info!("import session cleanup: removed {} expired sessions", n);
+        Ok(())
+    }
+}

crates/application/src/jobs/mod.rs

@@ -0,0 +1,11 @@
+mod enrichment_staleness;
+mod import_cleanup;
+mod refresh_session_cleanup;
+mod watch_event_cleanup;
+mod wrapup;
+
+pub use enrichment_staleness::EnrichmentStalenessJob;
+pub use import_cleanup::ImportSessionCleanupJob;
+pub use refresh_session_cleanup::RefreshSessionCleanupJob;
+pub use watch_event_cleanup::WatchEventCleanupJob;
+pub use wrapup::{WrapUpAutoGenerateJob, WrapUpCleanupJob};

crates/application/src/jobs/refresh_session_cleanup.rs

@@ -0,0 +1,31 @@
+use std::time::Duration;
+
+use async_trait::async_trait;
+use domain::{errors::DomainError, ports::PeriodicJob};
+
+use crate::context::AppContext;
+
+pub struct RefreshSessionCleanupJob {
+    ctx: AppContext,
+}
+
+impl RefreshSessionCleanupJob {
+    pub fn new(ctx: AppContext) -> Self {
+        Self { ctx }
+    }
+}
+
+#[async_trait]
+impl PeriodicJob for RefreshSessionCleanupJob {
+    fn interval(&self) -> Duration {
+        Duration::from_secs(86400)
+    }
+
+    async fn run(&self) -> Result<(), DomainError> {
+        let n = self.ctx.repos.refresh_session.delete_expired().await?;
+        if n > 0 {
+            tracing::info!("refresh session cleanup: removed {n} expired sessions");
+        }
+        Ok(())
+    }
+}

crates/application/src/jobs/watch_event_cleanup.rs

@@ -0,0 +1,31 @@
+use std::time::Duration;
+
+use async_trait::async_trait;
+use domain::{errors::DomainError, ports::PeriodicJob};
+
+use crate::context::AppContext;
+
+pub struct WatchEventCleanupJob {
+    ctx: AppContext,
+}
+
+impl WatchEventCleanupJob {
+    pub fn new(ctx: AppContext) -> Self {
+        Self { ctx }
+    }
+}
+
+#[async_trait]
+impl PeriodicJob for WatchEventCleanupJob {
+    fn interval(&self) -> Duration {
+        Duration::from_secs(86400)
+    }
+
+    async fn run(&self) -> Result<(), DomainError> {
+        let n = crate::integrations::cleanup::execute(&self.ctx).await?;
+        if n > 0 {
+            tracing::info!("watch event cleanup: removed {n} old entries");
+        }
+        Ok(())
+    }
+}

crates/application/src/jobs/wrapup.rs

@@ -2,91 +2,10 @@ use std::time::Duration;
 
 use async_trait::async_trait;
 use chrono::Datelike;
-use domain::{errors::DomainError, events::DomainEvent, ports::PeriodicJob};
+use domain::{errors::DomainError, ports::PeriodicJob};
 
 use crate::context::AppContext;
 
-pub struct ImportSessionCleanupJob {
-    ctx: AppContext,
-}
-
-impl ImportSessionCleanupJob {
-    pub fn new(ctx: AppContext) -> Self {
-        Self { ctx }
-    }
-}
-
-#[async_trait]
-impl PeriodicJob for ImportSessionCleanupJob {
-    fn interval(&self) -> Duration {
-        Duration::from_secs(3600)
-    }
-
-    async fn run(&self) -> Result<(), DomainError> {
-        let n = crate::import::cleanup::execute(&self.ctx).await?;
-        tracing::info!("import session cleanup: removed {} expired sessions", n);
-        Ok(())
-    }
-}
-
-pub struct WatchEventCleanupJob {
-    ctx: AppContext,
-}
-
-impl WatchEventCleanupJob {
-    pub fn new(ctx: AppContext) -> Self {
-        Self { ctx }
-    }
-}
-
-#[async_trait]
-impl PeriodicJob for WatchEventCleanupJob {
-    fn interval(&self) -> Duration {
-        Duration::from_secs(86400)
-    }
-
-    async fn run(&self) -> Result<(), DomainError> {
-        let n = crate::integrations::cleanup::execute(&self.ctx).await?;
-        if n > 0 {
-            tracing::info!("watch event cleanup: removed {n} old entries");
-        }
-        Ok(())
-    }
-}
-
-pub struct EnrichmentStalenessJob {
-    ctx: AppContext,
-}
-
-impl EnrichmentStalenessJob {
-    pub fn new(ctx: AppContext) -> Self {
-        Self { ctx }
-    }
-}
-
-#[async_trait]
-impl PeriodicJob for EnrichmentStalenessJob {
-    fn interval(&self) -> Duration {
-        Duration::from_secs(3600)
-    }
-
-    async fn run(&self) -> Result<(), DomainError> {
-        let stale = self.ctx.repos.movie_profile.list_stale().await?;
-        if stale.is_empty() {
-            return Ok(());
-        }
-        tracing::info!("enrichment scan: {} stale movies", stale.len());
-        for (movie_id, external_metadata_id) in stale {
-            let event = DomainEvent::MovieEnrichmentRequested {
-                movie_id,
-                external_metadata_id,
-            };
-            self.ctx.services.event_publisher.publish(&event).await?;
-        }
-        Ok(())
-    }
-}
-
 pub struct WrapUpAutoGenerateJob {
     ctx: AppContext,
 }
@@ -105,7 +24,6 @@ impl PeriodicJob for WrapUpAutoGenerateJob {
 
     async fn run(&self) -> Result<(), DomainError> {
         let now = chrono::Utc::now().naive_utc();
-        // Only run in January
         if now.month() != 1 {
             return Ok(());
         }
@@ -140,7 +58,6 @@ impl PeriodicJob for WrapUpAutoGenerateJob {
             }
         }
 
-        // Global wrap-up
         let existing = self
             .ctx
             .repos
@@ -162,31 +79,6 @@ impl PeriodicJob for WrapUpAutoGenerateJob {
     }
 }
 
-pub struct RefreshSessionCleanupJob {
-    ctx: AppContext,
-}
-
-impl RefreshSessionCleanupJob {
-    pub fn new(ctx: AppContext) -> Self {
-        Self { ctx }
-    }
-}
-
-#[async_trait]
-impl PeriodicJob for RefreshSessionCleanupJob {
-    fn interval(&self) -> Duration {
-        Duration::from_secs(86400)
-    }
-
-    async fn run(&self) -> Result<(), DomainError> {
-        let n = self.ctx.repos.refresh_session.delete_expired().await?;
-        if n > 0 {
-            tracing::info!("refresh session cleanup: removed {n} expired sessions");
-        }
-        Ok(())
-    }
-}
-
 pub struct WrapUpCleanupJob {
     ctx: AppContext,
 }

crates/application/src/test_helpers.rs

@@ -11,8 +11,8 @@ use domain::{
         MovieProfileRepository, MovieRepository, ObjectStorage, PasswordHasher, PersonCommand,
         PersonQuery, PosterFetcherClient, RefreshSessionRepository, ReviewRepository,
         SearchCommand, SearchPort, StatsRepository, UserProfileFieldsRepository, UserRepository,
-        UserSettingsRepository, WatchEventRepository, WatchlistRepository,
-        WebhookTokenRepository, WrapUpRepository, WrapUpStatsQuery,
+        UserSettingsRepository, WatchEventRepository, WatchlistRepository, WebhookTokenRepository,
+        WrapUpRepository, WrapUpStatsQuery,
     },
     testing::{
         FakeAuthService, FakeDiaryRepository, FakeDocumentParser, FakeMetadataClient,
@@ -21,8 +21,8 @@ use domain::{
         InMemoryMovieProfileRepository, InMemoryMovieRepository, InMemoryProfileFieldsRepo,
         InMemoryRefreshSessionRepository, InMemoryReviewRepository, InMemoryUserRepository,
         InMemoryUserSettingsRepository, InMemoryWatchEventRepository, InMemoryWatchlistRepository,
-        InMemoryWebhookTokenRepository, NoopEventPublisher, NoopObjectStorage,
-        PanicDiaryExporter, PanicPersonCommand,
+        InMemoryWebhookTokenRepository, NoopEventPublisher, NoopObjectStorage, PanicDiaryExporter,
+        PanicPersonCommand,
     },
 };