Keep the feed catalogue and server settings in the database

Phase 3 of #18. Two tables: catalogue (each feed's config::Feed as JSON, so a
new feed setting needs no column) and settings (general: the five server
settings the admin page edits). config.toml keeps what is needed before the
database is reached, or decides who gets in: paths, [torrent], [web].

ipx still runs from one in-memory Config, assembled at start from both
(assemble_config). The eight places that saved config.toml and re-read it now
call Ctx::store_cfg, which writes the database and swaps the copy in memory; the
first-run web token, which is config.toml's, is written there.

The first start on a database with no catalogue imports config.toml's feeds and
settings in one transaction whose first insert is the settings row, so two ipx
starting at once cannot both import; it then trims config.toml, keeping the
original as config.toml.pre-database. After that, feeds written into the file are
ignored with a warning. copy-db skips it, and copies both tables.

Rehearsed on a clone of production's database with production's config: all 130
feeds imported, the file trimmed, and the feed list, settings and directory
identical to the live server's.

Postgres connections now ask for no notices. Every CREATE ... IF NOT EXISTS on an
existing table sends one, eleven per open; sqlx logs them, and
tracing-subscriber 0.3.23's per-layer filters then dropped the next line ipx
logged -- the import's own message went missing that way. Proved by toggling it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/db.rs

@@ -2,7 +2,7 @@
 //! per-feed .ipxd plists, history.dat and qmcache.dat.
 
 use anyhow::{Context, Result};
-use crate::entity::{enclosures, entries, feeds, sessions, subscriptions, users};
+use crate::entity::{catalogue, enclosures, entries, feeds, sessions, settings, subscriptions, users};
 use sea_orm::sea_query::{Expr, Func};
 use sea_orm::{
     ActiveModelTrait, ColumnTrait, ConnectionTrait, EntityTrait, PaginatorTrait, QueryFilter, QueryOrder, Set,
@@ -55,6 +55,8 @@ async fn create_missing(orm: &sea_orm::DatabaseConnection) -> Result<()> {
         schema.create_table_from_entity(subscriptions::Entity),
         schema.create_table_from_entity(entry_state::Entity),
         schema.create_table_from_entity(sessions::Entity),
+        schema.create_table_from_entity(catalogue::Entity),
+        schema.create_table_from_entity(settings::Entity),
     ] {
         orm.execute(table.if_not_exists()).await.context("creating the schema")?;
     }
@@ -100,6 +102,9 @@ pub fn location() -> String {
         .unwrap_or_else(|| crate::config::data_dir().join("state.db").display().to_string())
 }
 
+/// The Postgres connection option that keeps notices from being sent at all; see `connect`.
+const QUIET: &str = "options=-c%20client_min_messages%3Dwarning";
+
 /// A URL fit for a log or an error: the password taken out.
 fn redact(url: &str) -> String {
     match (url.find("://"), url.rfind('@')) {
@@ -118,15 +123,30 @@ fn is_postgres(location: &str) -> bool {
 /// sqlx's defaults for SQLite are what ipx wants: foreign keys on, and a five-second wait for a
 /// lock, which is what rusqlite was set to.
 async fn connect(location: &str) -> Result<sea_orm::DatabaseConnection> {
-    let url =
-        if is_postgres(location) { location.to_owned() } else { format!("sqlite://{location}?mode=rwc") };
-    let mut opts = sea_orm::ConnectOptions::new(url);
+    let mut opts = sea_orm::ConnectOptions::new(url_for(location));
     opts.sqlx_logging(false);
     sea_orm::Database::connect(opts)
         .await
         .with_context(|| format!("opening {}", redact(location)))
 }
 
+/// The URL `connect` hands sqlx for a location: a SQLite file, created if missing, or a Postgres
+/// URL with notices turned off.
+fn url_for(location: &str) -> String {
+    if !is_postgres(location) {
+        format!("sqlite://{location}?mode=rwc")
+    } else if location.contains("options=") {
+        location.to_owned() // someone chose their own; theirs stands
+    } else {
+        // Warnings and up only. Postgres answers every CREATE ... IF NOT EXISTS on an existing
+        // table with a notice, eleven on each open; sqlx logs each, no filter here wants them,
+        // and tracing-subscriber's per-layer filters then swallowed the next line ipx logged
+        // (0.3.23: "moved the feeds ... into the database" went missing that way).
+        let sep = if location.contains('?') { '&' } else { '?' };
+        format!("{location}{sep}{QUIET}")
+    }
+}
+
 
 /// One person's wants for one feed. `None` in a field means the feed's own setting stands.
 #[derive(Debug, Clone, Default)]
@@ -280,7 +300,9 @@ impl Db {
             admin.execute_unprepared(&format!("CREATE SCHEMA {schema}")).await?;
             // Every connection in the pool starts in it, so each test sees only its own tables.
             let sep = if url.contains('?') { '&' } else { '?' };
-            let orm = connect(&format!("{url}{sep}options=-c%20search_path%3D{schema}")).await?;
+            let orm =
+                connect(&format!("{url}{sep}options=-c%20search_path%3D{schema}%20-c%20client_min_messages%3Dwarning"))
+                    .await?;
             create_missing(&orm).await?;
             return Ok(Self { orm, tmp: None });
         }
@@ -963,6 +985,76 @@ impl Db {
         Ok(())
     }
 
+    // ---- the configuration: the catalogue and the server settings ----
+
+    /// The feeds and server settings, once the database holds them; None before, when they are
+    /// still config.toml's.
+    pub async fn stored_config(
+        &self,
+    ) -> Result<Option<(crate::config::Stored, std::collections::BTreeMap<String, crate::config::Feed>)>> {
+        let Some(general) = settings::Entity::find_by_id("general".to_owned()).one(&self.orm).await? else {
+            return Ok(None);
+        };
+        let stored = serde_json::from_str(&general.value).context("reading the stored server settings")?;
+        let mut feeds = std::collections::BTreeMap::new();
+        for row in catalogue::Entity::find().all(&self.orm).await? {
+            let feed = serde_json::from_str(&row.spec).with_context(|| format!("reading feed {}", row.id))?;
+            feeds.insert(row.id, feed);
+        }
+        Ok(Some((stored, feeds)))
+    }
+
+    /// Takes the feeds and server settings from `cfg` (config.toml, as read) into a database that
+    /// has none. False when it already had them: another process got there first, and its copy
+    /// stands. One transaction, and the settings row goes in first, so two processes starting at
+    /// once cannot both import.
+    pub async fn import_config(&self, cfg: &crate::config::Config) -> Result<bool> {
+        use sea_orm::TransactionTrait;
+        let backend = self.orm.get_database_backend();
+        let tx = self.orm.begin().await?;
+        let claimed = tx
+            .execute_raw(Statement::from_sql_and_values(
+                backend,
+                "INSERT INTO settings (name, value) VALUES ('general', $1) ON CONFLICT DO NOTHING",
+                vec![serde_json::to_string(&crate::config::Stored::of(cfg))?.into()],
+            ))
+            .await?
+            .rows_affected();
+        if claimed == 0 {
+            return Ok(false); // dropped, so rolled back
+        }
+        for (id, feed) in &cfg.feeds {
+            catalogue::ActiveModel { id: Set(id.clone()), spec: Set(serde_json::to_string(feed)?) }
+                .insert(&tx)
+                .await?;
+        }
+        tx.commit().await?;
+        Ok(true)
+    }
+
+    /// Writes the feeds and server settings as they now stand: what config.toml's save did.
+    /// The whole catalogue at once, in one transaction, so a feed removed goes too.
+    pub async fn store_config(&self, cfg: &crate::config::Config) -> Result<()> {
+        use sea_orm::TransactionTrait;
+        let backend = self.orm.get_database_backend();
+        let tx = self.orm.begin().await?;
+        tx.execute_raw(Statement::from_sql_and_values(
+            backend,
+            "INSERT INTO settings (name, value) VALUES ('general', $1)
+             ON CONFLICT (name) DO UPDATE SET value = excluded.value",
+            vec![serde_json::to_string(&crate::config::Stored::of(cfg))?.into()],
+        ))
+        .await?;
+        catalogue::Entity::delete_many().exec(&tx).await?;
+        for (id, feed) in &cfg.feeds {
+            catalogue::ActiveModel { id: Set(id.clone()), spec: Set(serde_json::to_string(feed)?) }
+                .insert(&tx)
+                .await?;
+        }
+        tx.commit().await?;
+        Ok(())
+    }
+
     // ---- moving to another database ----
 
     /// Copies every row of `from` into this database, which must be empty: the move from the
@@ -985,6 +1077,8 @@ impl Db {
             ("subscriptions", copy_table::<subscriptions::Entity>(&from.orm, &tx).await?),
             ("entry_state", copy_table::<entry_state::Entity>(&from.orm, &tx).await?),
             ("sessions", copy_table::<sessions::Entity>(&from.orm, &tx).await?),
+            ("catalogue", copy_table::<catalogue::Entity>(&from.orm, &tx).await?),
+            ("settings", copy_table::<settings::Entity>(&from.orm, &tx).await?),
         ];
         if self.orm.get_database_backend() == sea_orm::DbBackend::Postgres {
             // The copied ids came with the rows; the counters that hand out new ones start past
@@ -2077,6 +2171,51 @@ mod tests {
         assert!(db.pinned_feeds(me).await.unwrap().is_empty());
     }
 
+    #[test]
+    fn postgres_is_asked_for_no_notices_and_a_password_never_reaches_a_log() {
+        assert_eq!(url_for("postgres://u:p@h/d"), format!("postgres://u:p@h/d?{QUIET}"));
+        assert_eq!(url_for("postgres://u:p@h/d?sslmode=disable"), format!("postgres://u:p@h/d?sslmode=disable&{QUIET}"));
+        assert_eq!(url_for("postgres://u:p@h/d?options=-c%20x%3Dy"), "postgres://u:p@h/d?options=-c%20x%3Dy", "theirs stands");
+        assert_eq!(url_for("/data/state.db"), "sqlite:///data/state.db?mode=rwc");
+        assert_eq!(redact("postgres://ipodderx:s3cret@h:5433/ipodderx"), "postgres://ipodderx:***@h:5433/ipodderx");
+    }
+
+    #[tokio::test]
+    async fn the_configuration_goes_in_once_and_comes_back_as_it_went() {
+        let db = Db::memory().await.unwrap();
+        assert!(db.stored_config().await.unwrap().is_none(), "nothing until it is taken in");
+        let mut cfg: crate::config::Config = toml::from_str(
+            r#"
+            [general]
+            schedule = "every 2h"
+            max_total_gb = 1.5
+            [feeds.a]
+            url = "http://x/a.xml"
+            keywords = ["one", "two"]
+            [feeds.b]
+            url = "http://x/b.xml"
+            password = "secret"
+            "#,
+        )
+        .unwrap();
+        assert!(db.import_config(&cfg).await.unwrap());
+        assert!(!db.import_config(&cfg).await.unwrap(), "a second import finds the first and stands back");
+        let (stored, feeds) = db.stored_config().await.unwrap().unwrap();
+        assert_eq!(stored, crate::config::Stored::of(&cfg));
+        assert_eq!(feeds.keys().collect::<Vec<_>>(), ["a", "b"]);
+        assert_eq!(feeds["a"].keywords, ["one", "two"]);
+        assert_eq!(feeds["b"].password.as_deref(), Some("secret"));
+
+        // Storing is the whole catalogue: a feed taken out goes, one put in arrives.
+        cfg.feeds.remove("a");
+        cfg.feeds.insert("c".into(), cfg.feeds["b"].clone());
+        cfg.general.schedule = "every 30m".into();
+        db.store_config(&cfg).await.unwrap();
+        let (stored, feeds) = db.stored_config().await.unwrap().unwrap();
+        assert_eq!(stored.schedule, "every 30m");
+        assert_eq!(feeds.keys().collect::<Vec<_>>(), ["b", "c"]);
+    }
+
     #[tokio::test]
     async fn enclosure_url_is_the_dedupe_key() {
         let db = Db::memory().await.unwrap();