refactor: drop postgres backend

crates/composition/src/factory.rs

@@ -48,126 +48,59 @@ pub struct DatabaseOutput {
 }
 
 pub async fn build_database_adapters(
-    backend: &str,
     url: &str,
     instance: &domain::value_objects::InstanceIdentity,
 ) -> anyhow::Result<DatabaseOutput> {
-    match backend {
-        #[cfg(feature = "postgres")]
-        "postgres" => {
-            let w = postgres::wire(url)
-                .await
-                .context("PostgreSQL connection failed")?;
-            let (image_ref_command, image_ref_query) = postgres::create_image_ref(w.pool.clone());
-            let (pc, pq) = postgres::create_person_adapter(w.pool.clone());
-            let (sc, sp) = postgres_search::create_search_adapter(w.pool.clone());
-            let pf = postgres::create_profile_fields_repo(w.pool.clone());
-            let we = Arc::new(postgres::PostgresWatchEventRepository::new(w.pool.clone()));
-            let wt: Arc<dyn WebhookTokenRepository> = Arc::new(
-                postgres::PostgresWebhookTokenRepository::new(w.pool.clone()),
-            );
-            let social = Arc::new(postgres_social::PostgresSocialRepository::new(
-                w.pool.clone(),
-                instance.clone(),
-            ));
-            Ok(DatabaseOutput {
-                movie_command: w.movie_command,
-                movie_query: w.movie_query,
-                review: w.review,
-                diary: w.diary,
-                stats: w.stats,
-                user: w.user,
-                import_session: w.import_session,
-                import_profile: w.import_profile,
-                movie_profile: w.movie_profile,
-                watchlist: w.watchlist,
-                watch_event_command: we.clone() as _,
-                watch_event_query: we as _,
-                webhook_token: wt,
-                person_command: pc,
-                person_query: pq,
-                search_port: sp,
-                search_command: sc,
-                profile_fields: pf,
-                ap_content: w.ap_content,
-                wrapup_stats: w.wrapup_stats,
-                wrapup_repo: w.wrapup_repo,
-                insights: w.insights,
-                goal_command: w.goal_command,
-                goal_query: w.goal_query,
-                user_settings: w.user_settings,
-                federation_settings: w.federation_settings,
-                remote_goal: w.remote_goal,
-                refresh_session: Arc::new(postgres::PostgresRefreshSessionAdapter::new(
-                    w.pool.clone(),
-                )) as _,
-                deduplicator: w.deduplicator,
-                image_ref_command,
-                image_ref_query,
-                follow_command: Arc::clone(&social) as _,
-                follow_query: social as _,
-                db_pool: DbPool::Postgres(w.pool),
-            })
-        }
-        #[cfg(feature = "sqlite")]
-        _ => {
-            let w = sqlite::wire(url)
-                .await
-                .context("SQLite connection failed")?;
-            let (image_ref_command, image_ref_query) = sqlite::create_image_ref(w.pool.clone());
-            let (pc, pq) = sqlite::create_person_adapter(w.pool.clone());
-            let (sc, sp) = sqlite_search::create_search_adapter(w.pool.clone());
-            let pf = sqlite::create_profile_fields_repo(w.pool.clone());
-            let we = Arc::new(sqlite::SqliteWatchEventRepository::new(w.pool.clone()));
-            let wt: Arc<dyn WebhookTokenRepository> =
-                Arc::new(sqlite::SqliteWebhookTokenRepository::new(w.pool.clone()));
-            let social = Arc::new(sqlite_social::SqliteSocialRepository::new(
-                w.pool.clone(),
-                instance.clone(),
-            ));
-            Ok(DatabaseOutput {
-                movie_command: w.movie_command,
-                movie_query: w.movie_query,
-                review: w.review,
-                diary: w.diary,
-                stats: w.stats,
-                user: w.user,
-                import_session: w.import_session,
-                import_profile: w.import_profile,
-                movie_profile: w.movie_profile,
-                watchlist: w.watchlist,
-                watch_event_command: we.clone() as _,
-                watch_event_query: we as _,
-                webhook_token: wt,
-                person_command: pc,
-                person_query: pq,
-                search_port: sp,
-                search_command: sc,
-                profile_fields: pf,
-                ap_content: w.ap_content,
-                wrapup_stats: w.wrapup_stats,
-                wrapup_repo: w.wrapup_repo,
-                insights: w.insights,
-                goal_command: w.goal_command,
-                goal_query: w.goal_query,
-                user_settings: w.user_settings,
-                federation_settings: w.federation_settings,
-                remote_goal: w.remote_goal,
-                refresh_session: Arc::new(sqlite::SqliteRefreshSessionAdapter::new(w.pool.clone()))
-                    as _,
-                deduplicator: w.deduplicator,
-                image_ref_command,
-                image_ref_query,
-                follow_command: Arc::clone(&social) as _,
-                follow_query: social as _,
-                db_pool: DbPool::Sqlite(w.pool),
-            })
-        }
-        #[cfg(not(feature = "sqlite"))]
-        _ => anyhow::bail!(
-            "DATABASE_BACKEND={backend} is not supported by this build (enable sqlite or postgres feature)"
-        ),
-    }
+    let w = sqlite::wire(url)
+        .await
+        .context("SQLite connection failed")?;
+    let (image_ref_command, image_ref_query) = sqlite::create_image_ref(w.pool.clone());
+    let (pc, pq) = sqlite::create_person_adapter(w.pool.clone());
+    let (sc, sp) = sqlite_search::create_search_adapter(w.pool.clone());
+    let pf = sqlite::create_profile_fields_repo(w.pool.clone());
+    let we = Arc::new(sqlite::SqliteWatchEventRepository::new(w.pool.clone()));
+    let wt: Arc<dyn WebhookTokenRepository> =
+        Arc::new(sqlite::SqliteWebhookTokenRepository::new(w.pool.clone()));
+    let social = Arc::new(sqlite_social::SqliteSocialRepository::new(
+        w.pool.clone(),
+        instance.clone(),
+    ));
+    Ok(DatabaseOutput {
+        movie_command: w.movie_command,
+        movie_query: w.movie_query,
+        review: w.review,
+        diary: w.diary,
+        stats: w.stats,
+        user: w.user,
+        import_session: w.import_session,
+        import_profile: w.import_profile,
+        movie_profile: w.movie_profile,
+        watchlist: w.watchlist,
+        watch_event_command: we.clone() as _,
+        watch_event_query: we as _,
+        webhook_token: wt,
+        person_command: pc,
+        person_query: pq,
+        search_port: sp,
+        search_command: sc,
+        profile_fields: pf,
+        ap_content: w.ap_content,
+        wrapup_stats: w.wrapup_stats,
+        wrapup_repo: w.wrapup_repo,
+        insights: w.insights,
+        goal_command: w.goal_command,
+        goal_query: w.goal_query,
+        user_settings: w.user_settings,
+        federation_settings: w.federation_settings,
+        remote_goal: w.remote_goal,
+        refresh_session: Arc::new(sqlite::SqliteRefreshSessionAdapter::new(w.pool.clone())) as _,
+        deduplicator: w.deduplicator,
+        image_ref_command,
+        image_ref_query,
+        follow_command: Arc::clone(&social) as _,
+        follow_query: social as _,
+        db_pool: DbPool::Sqlite(w.pool),
+    })
 }
 
 pub fn build_auth_adapters() -> anyhow::Result<(Arc<dyn AuthService>, Arc<dyn PasswordHasher>)> {
@@ -190,8 +123,6 @@ pub fn build_profile_fields_repo(
     pool: &DbPool,
 ) -> anyhow::Result<Arc<dyn UserProfileFieldsRepository>> {
     match pool {
-        #[cfg(feature = "postgres")]
-        DbPool::Postgres(pool) => Ok(postgres::create_profile_fields_repo(pool.clone())),
         #[cfg(feature = "sqlite")]
         DbPool::Sqlite(pool) => Ok(sqlite::create_profile_fields_repo(pool.clone())),
         #[cfg(not(feature = "sqlite"))]