server: more news title/body cleanup, and don't search news so much

server/src/graphql.rs

@@ -8,7 +8,7 @@ use notmuch::Notmuch;
 use serde::{Deserialize, Serialize};
 use sqlx::postgres::PgPool;
 
-use crate::{newsreader, nm};
+use crate::{newsreader, nm, Query};
 
 /// # Number of seconds since the Epoch
 pub type UnixTime = isize;
@@ -215,7 +215,7 @@ impl QueryRoot {
         let nm = ctx.data_unchecked::<Notmuch>();
         let pool = ctx.data_unchecked::<PgPool>();
 
-        let newsreader_query: newsreader::Query = query.parse()?;
+        let newsreader_query: Query = query.parse()?;
 
         Ok(newsreader::count(pool, &newsreader_query).await? + nm::count(nm, &query).await?)
     }
@@ -257,32 +257,46 @@ impl QueryRoot {
                 let newsreader_before = before.as_ref().map(|sc| sc.newsreader_offset);
                 let notmuch_before = before.as_ref().map(|sc| sc.notmuch_offset);
 
-                let newsreader_query: newsreader::Query = query.parse()?;
-                let newsreader_results = newsreader::search(
-                    pool,
-                    newsreader_after,
-                    newsreader_before,
-                    first.map(|v| v as i32),
-                    last.map(|v| v as i32),
-                    &newsreader_query,
-                )
-                .await?
-                .into_iter()
-                .map(|(cur, ts)| ThreadSummaryCursor::Newsreader(cur, ts));
+                let newsreader_query: Query = query.parse()?;
+                info!("newsreader_query {newsreader_query:?}");
+                let newsreader_results = if newsreader_query.is_newsreader {
+                    newsreader::search(
+                        pool,
+                        newsreader_after,
+                        newsreader_before,
+                        first.map(|v| v as i32),
+                        last.map(|v| v as i32),
+                        &newsreader_query,
+                    )
+                    .await?
+                    .into_iter()
+                    .map(|(cur, ts)| ThreadSummaryCursor::Newsreader(cur, ts))
+                    .collect()
+                } else {
+                    Vec::new()
+                };
 
-                let notmuch_results = nm::search(
-                    nm,
-                    notmuch_after,
-                    notmuch_before,
-                    first.map(|v| v as i32),
-                    last.map(|v| v as i32),
-                    query,
-                )
-                .await?
-                .into_iter()
-                .map(|(cur, ts)| ThreadSummaryCursor::Notmuch(cur, ts));
+                let notmuch_results = if newsreader_query.is_notmuch {
+                    nm::search(
+                        nm,
+                        notmuch_after,
+                        notmuch_before,
+                        first.map(|v| v as i32),
+                        last.map(|v| v as i32),
+                        newsreader_query.to_notmuch(),
+                    )
+                    .await?
+                    .into_iter()
+                    .map(|(cur, ts)| ThreadSummaryCursor::Notmuch(cur, ts))
+                    .collect()
+                } else {
+                    Vec::new()
+                };
 
-                let mut results: Vec<_> = newsreader_results.chain(notmuch_results).collect();
+                let mut results: Vec<_> = newsreader_results
+                    .into_iter()
+                    .chain(notmuch_results)
+                    .collect();
 
                 // The leading '-' is to reverse sort
                 results.sort_by_key(|item| match item {