Merge news and email search results

server/src/nm.rs

@@ -5,13 +5,13 @@ use std::{
     time::Instant,
 };
 
-use async_graphql::connection::{self, Connection, Edge};
 use log::{error, info, warn};
 use mailparse::{parse_mail, MailHeader, MailHeaderMap, ParsedMail};
 use memmap::MmapOptions;
 use notmuch::Notmuch;
 
 use crate::{
+    compute_offset_limit,
     error::ServerError,
     graphql::{
         Attachment, Body, DispositionType, Email, Header, Html, Message, PlainText, Tag, Thread,
@@ -44,41 +44,22 @@ pub async fn count(nm: &Notmuch, query: &str) -> Result<usize, ServerError> {
 
 pub async fn search(
     nm: &Notmuch,
-    after: Option<String>,
-    before: Option<String>,
+    after: Option<i32>,
+    before: Option<i32>,
     first: Option<i32>,
     last: Option<i32>,
     query: String,
-) -> Result<Connection<usize, ThreadSummary>, async_graphql::Error> {
-    connection::query(
-        after,
-        before,
-        first,
-        last,
-        |after, before, first, last| async move {
-            let total = nm.count(&query)?;
-            let (first, last) = if let (None, None) = (first, last) {
-                info!("neither first nor last set, defaulting first to 20");
-                (Some(20), None)
-            } else {
-                (first, last)
-            };
-
-            let mut start = after.map(|after| after + 1).unwrap_or(0);
-            let mut end = before.unwrap_or(total);
-            if let Some(first) = first {
-                end = (start + first).min(end);
-            }
-            if let Some(last) = last {
-                start = if last > end - start { end } else { end - last };
-            }
-
-            let count = end - start;
-            let slice: Vec<ThreadSummary> = nm
-                .search(&query, start, count)?
-                .0
-                .into_iter()
-                .map(|ts| ThreadSummary {
+) -> Result<Vec<(i32, ThreadSummary)>, async_graphql::Error> {
+    let (offset, limit) = compute_offset_limit(after, before, first, last);
+    Ok(nm
+        .search(&query, offset as usize, limit as usize)?
+        .0
+        .into_iter()
+        .enumerate()
+        .map(|(i, ts)| {
+            (
+                offset + i as i32,
+                ThreadSummary {
                     thread: format!("thread:{}", ts.thread),
                     timestamp: ts.timestamp,
                     date_relative: ts.date_relative,
@@ -87,20 +68,10 @@ pub async fn search(
                     authors: ts.authors,
                     subject: ts.subject,
                     tags: ts.tags,
-                })
-                .collect();
-
-            let mut connection = Connection::new(start > 0, end < total);
-            connection.edges.extend(
-                slice
-                    .into_iter()
-                    .enumerate()
-                    .map(|(idx, item)| Edge::new(start + idx, item)),
-            );
-            Ok::<_, async_graphql::Error>(connection)
-        },
-    )
-    .await
+                },
+            )
+        })
+        .collect())
 }
 
 pub fn tags(nm: &Notmuch, needs_unread: bool) -> Result<Vec<Tag>, ServerError> {