refactor: replace unwrap() with expect() in production code

- Use expect() with descriptive messages for lock poisoning
- Handle SQL prepare errors gracefully with early returns
- Log HTTP server errors instead of panicking

Author: jimmystridh

src/http.rs

@@ -70,12 +70,14 @@ pub async fn run_http_server(
         .fallback(not_found)
         .with_state(state);
 
-    axum::serve(listener, app)
+    if let Err(e) = axum::serve(listener, app)
         .with_graceful_shutdown(async move {
             let _ = shutdown.recv().await;
         })
         .await
-        .unwrap();
+    {
+        tracing::error!("HTTP server error: {e}");
+    }
 }
 
 async fn serve_index() -> Html<&'static str> {

src/lib.rs

@@ -176,7 +176,7 @@ pub async fn start_sink(opts: SinkOptions) -> std::io::Result<RunningServers> {
     let smtp_store = Arc::clone(&store);
     let smtp_shutdown = shutdown_tx.subscribe();
     let smtp_handle = if opts.tls {
-        let acceptor = tls_acceptor.clone().unwrap();
+        let acceptor = tls_acceptor.clone().expect("TLS acceptor required when tls=true");
         tokio::spawn(async move {
             smtp::run_smtps_server(smtp_listener, smtp_store, smtp_config, acceptor, smtp_shutdown)
                 .await;

src/sqlite_store.rs

@@ -125,7 +125,7 @@ impl SqliteStore {
 #[allow(clippy::significant_drop_tightening)]
 impl EmailStorage for SqliteStore {
     fn push(&self, email: MailRecord) {
-        let conn = self.conn.lock().unwrap();
+        let conn = self.conn.lock().expect("lock poisoned");
 
         let to_json = serde_json::to_string(&email.to).unwrap_or_default();
         let headers_json = serde_json::to_string(&email.headers).unwrap_or_default();
@@ -170,10 +170,12 @@ impl EmailStorage for SqliteStore {
     }
 
     fn get_all(&self) -> Vec<MailRecord> {
-        let conn = self.conn.lock().unwrap();
-        let mut stmt = conn
+        let conn = self.conn.lock().expect("lock poisoned");
+        let Ok(mut stmt) = conn
             .prepare("SELECT id, from_addr, to_addrs, subject, text_body, html_body, date, headers, raw FROM emails ORDER BY created_at DESC")
-            .unwrap();
+        else {
+            return Vec::new();
+        };
 
         let mut records: Vec<MailRecord> = stmt
             .query_map([], Self::row_to_record)
@@ -188,7 +190,7 @@ impl EmailStorage for SqliteStore {
     }
 
     fn get_by_id(&self, id: &str) -> Option<MailRecord> {
-        let conn = self.conn.lock().unwrap();
+        let conn = self.conn.lock().expect("lock poisoned");
         let mut stmt = conn
             .prepare("SELECT id, from_addr, to_addrs, subject, text_body, html_body, date, headers, raw FROM emails WHERE id = ?")
             .ok()?;
@@ -199,7 +201,7 @@ impl EmailStorage for SqliteStore {
     }
 
     fn query(&self, query: &EmailQuery) -> Vec<MailRecord> {
-        let conn = self.conn.lock().unwrap();
+        let conn = self.conn.lock().expect("lock poisoned");
 
         let mut sql = String::from(
             "SELECT id, from_addr, to_addrs, subject, text_body, html_body, date, headers, raw FROM emails WHERE 1=1"
@@ -248,7 +250,7 @@ impl EmailStorage for SqliteStore {
     }
 
     fn get_attachment(&self, email_id: &str, filename: &str) -> Option<Attachment> {
-        let conn = self.conn.lock().unwrap();
+        let conn = self.conn.lock().expect("lock poisoned");
         let mut stmt = conn
             .prepare("SELECT filename, content_type, content_id, data, size FROM attachments WHERE email_id = ? AND filename = ?")
             .ok()?;
@@ -266,7 +268,7 @@ impl EmailStorage for SqliteStore {
     }
 
     fn get_attachment_by_cid(&self, email_id: &str, cid: &str) -> Option<Attachment> {
-        let conn = self.conn.lock().unwrap();
+        let conn = self.conn.lock().expect("lock poisoned");
         let mut stmt = conn
             .prepare("SELECT filename, content_type, content_id, data, size FROM attachments WHERE email_id = ? AND content_id = ?")
             .ok()?;
@@ -284,14 +286,14 @@ impl EmailStorage for SqliteStore {
     }
 
     fn clear(&self) {
-        let conn = self.conn.lock().unwrap();
+        let conn = self.conn.lock().expect("lock poisoned");
         let _ = conn.execute("DELETE FROM emails", []);
         drop(conn);
         let _ = self.notify.send(());
     }
 
     fn remove(&self, id: &str) -> bool {
-        let conn = self.conn.lock().unwrap();
+        let conn = self.conn.lock().expect("lock poisoned");
         let result = conn.execute("DELETE FROM emails WHERE id = ?", params![id]);
         let removed = result.map(|n| n > 0).unwrap_or(false);
         drop(conn);
@@ -302,7 +304,7 @@ impl EmailStorage for SqliteStore {
     }
 
     fn close(&self) {
-        let conn = self.conn.lock().unwrap();
+        let conn = self.conn.lock().expect("lock poisoned");
         // Checkpoint WAL to ensure all data is written to the main database file
         let _ = conn.execute_batch("PRAGMA wal_checkpoint(TRUNCATE);");
         tracing::info!("SQLite database checkpointed and ready for shutdown");

src/store.rs

@@ -49,7 +49,7 @@ impl MemoryStore {
 
 impl EmailStorage for MemoryStore {
     fn push(&self, email: MailRecord) {
-        let mut emails = self.emails.write().unwrap();
+        let mut emails = self.emails.write().expect("lock poisoned");
         emails.push(email);
         while emails.len() > self.max {
             emails.remove(0);
@@ -59,15 +59,15 @@ impl EmailStorage for MemoryStore {
     }
 
     fn get_all(&self) -> Vec<MailRecord> {
-        self.emails.read().unwrap().clone()
+        self.emails.read().expect("lock poisoned").clone()
     }
 
     fn get_by_id(&self, id: &str) -> Option<MailRecord> {
-        self.emails.read().unwrap().iter().find(|e| e.id == id).cloned()
+        self.emails.read().expect("lock poisoned").iter().find(|e| e.id == id).cloned()
     }
 
     fn query(&self, query: &EmailQuery) -> Vec<MailRecord> {
-        let emails = self.emails.read().unwrap();
+        let emails = self.emails.read().expect("lock poisoned");
         emails
             .iter()
             .filter(|e| matches_query(e, query))
@@ -77,25 +77,25 @@ impl EmailStorage for MemoryStore {
 
     #[allow(clippy::significant_drop_tightening)]
     fn get_attachment(&self, email_id: &str, filename: &str) -> Option<Attachment> {
-        let emails = self.emails.read().unwrap();
+        let emails = self.emails.read().expect("lock poisoned");
         let email = emails.iter().find(|e| e.id == email_id)?;
         email.attachments.iter().find(|a| a.filename == filename).cloned()
     }
 
     #[allow(clippy::significant_drop_tightening)]
     fn get_attachment_by_cid(&self, email_id: &str, cid: &str) -> Option<Attachment> {
-        let emails = self.emails.read().unwrap();
+        let emails = self.emails.read().expect("lock poisoned");
         let email = emails.iter().find(|e| e.id == email_id)?;
         email.attachments.iter().find(|a| a.content_id.as_deref() == Some(cid)).cloned()
     }
 
     fn clear(&self) {
-        self.emails.write().unwrap().clear();
+        self.emails.write().expect("lock poisoned").clear();
         let _ = self.notify.send(());
     }
 
     fn remove(&self, id: &str) -> bool {
-        let mut emails = self.emails.write().unwrap();
+        let mut emails = self.emails.write().expect("lock poisoned");
         let Some(pos) = emails.iter().position(|e| e.id == id) else {
             return false;
         };