v0.1.1

src/db/contacts.rs

@@ -1,5 +1,5 @@
+use crate::db::pool::{Connection, params};
 use crate::queries::sqlite::queries::db_contacts::CONTACT_SELECT_COLS;
-use rusqlite::{Connection, params};
 use serde::Serialize;
 use uuid::Uuid;
 
@@ -33,7 +33,7 @@ pub struct Contact {
     pub has_photo: bool,
 }
 
-fn row_to_contact(row: &rusqlite::Row<'_>) -> rusqlite::Result<Contact> {
+fn row_to_contact(row: &crate::db::pool::Row<'_>) -> Result<Contact, crate::db::pool::DbError> {
     Ok(Contact {
         id: row.get(0)?,
         email: row.get(1)?,
@@ -60,14 +60,14 @@ fn row_to_contact(row: &rusqlite::Row<'_>) -> rusqlite::Result<Contact> {
 }
 
 fn escape_like(term: &str) -> String {
-    term.replace('\\', "\\\\")
-        .replace('%', "\\%")
-        .replace('_', "\\_")
+    term.replace('!', "!!")
+        .replace('%', "!%")
+        .replace('_', "!_")
 }
 
 pub fn upsert_contact(conn: &Connection, contact: &Contact) -> Result<(), String> {
     conn.execute(
-        crate::queries::sqlite::queries::db_contacts::Q_001,
+        crate::dbq!(db_contacts::Q_001),
         params![
             contact.id,
             contact.email,
@@ -95,23 +95,25 @@ pub fn upsert_contact(conn: &Connection, contact: &Contact) -> Result<(), String
 }
 
 pub fn get_contact(conn: &Connection, id: &str) -> Result<Option<Contact>, String> {
-    let sql = crate::rustbox_query_db_contacts_001!();
+    let sql =
+        crate::dbq!(db_contacts::FORMAT_001).replace("{CONTACT_SELECT_COLS}", CONTACT_SELECT_COLS);
     let result = conn.query_row(&sql, params![id], row_to_contact);
 
     match result {
         Ok(c) => Ok(Some(c)),
-        Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
+        Err(crate::db::pool::DbError::QueryReturnedNoRows) => Ok(None),
         Err(e) => Err(format!("Failed to get contact: {e}")),
     }
 }
 
 pub fn get_contact_by_email(conn: &Connection, email: &str) -> Result<Option<Contact>, String> {
-    let sql = crate::rustbox_query_db_contacts_002!();
+    let sql =
+        crate::dbq!(db_contacts::FORMAT_002).replace("{CONTACT_SELECT_COLS}", CONTACT_SELECT_COLS);
     let result = conn.query_row(&sql, params![email], row_to_contact);
 
     match result {
         Ok(c) => Ok(Some(c)),
-        Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
+        Err(crate::db::pool::DbError::QueryReturnedNoRows) => Ok(None),
         Err(e) => Err(format!("Failed to get contact by email: {e}")),
     }
 }
@@ -126,13 +128,15 @@ pub fn list_contacts(
         Some(q) if !q.is_empty() => {
             let escaped = escape_like(q);
             let pattern = format!("%{escaped}%");
-            let sql = crate::rustbox_query_db_contacts_003!();
+            let sql = crate::dbq!(db_contacts::FORMAT_003)
+                .replace("{CONTACT_SELECT_COLS}", CONTACT_SELECT_COLS);
 
             drop(pattern);
             (sql, Some(escaped))
         }
         _ => {
-            let sql = crate::rustbox_query_db_contacts_004!();
+            let sql = crate::dbq!(db_contacts::FORMAT_004)
+                .replace("{CONTACT_SELECT_COLS}", CONTACT_SELECT_COLS);
             (sql, None)
         }
     };
@@ -170,10 +174,7 @@ pub fn list_contacts(
 
 pub fn delete_contact(conn: &Connection, id: &str) -> Result<bool, String> {
     let deleted = conn
-        .execute(
-            crate::queries::sqlite::queries::db_contacts::Q_002,
-            params![id],
-        )
+        .execute(crate::dbq!(db_contacts::Q_002), params![id])
         .map_err(|e| format!("Failed to delete contact: {e}"))?;
     Ok(deleted > 0)
 }
@@ -182,7 +183,8 @@ pub fn search_contacts(conn: &Connection, query: &str, limit: u32) -> Result<Vec
     let escaped = escape_like(query);
     let pattern = format!("%{escaped}%");
 
-    let sql = crate::rustbox_query_db_contacts_005!();
+    let sql =
+        crate::dbq!(db_contacts::FORMAT_005).replace("{CONTACT_SELECT_COLS}", CONTACT_SELECT_COLS);
 
     let mut stmt = conn
         .prepare(&sql)
@@ -206,7 +208,7 @@ pub fn search_known_addresses(
     let escaped = escape_like(query);
     let pattern = format!("%{escaped}%");
 
-    let sql = crate::queries::sqlite::queries::db_contacts::Q_003;
+    let sql = crate::dbq!(db_contacts::Q_003);
 
     let mut stmt = conn
         .prepare(sql)
@@ -237,7 +239,7 @@ pub fn populate_known_addresses(
 ) -> Result<(), String> {
     if !from_address.is_empty() {
         conn.execute(
-            crate::queries::sqlite::queries::db_contacts::Q_004,
+            crate::dbq!(db_contacts::Q_004),
             params![from_address, from_name],
         )
         .map_err(|e| format!("Failed to insert known address (from): {e}"))?;
@@ -262,11 +264,8 @@ fn insert_addresses_from_json(conn: &Connection, json: &str) -> Result<(), Strin
             continue;
         }
         let name = entry.get("name").and_then(|v| v.as_str()).unwrap_or("");
-        conn.execute(
-            crate::queries::sqlite::queries::db_contacts::Q_005,
-            params![email, name],
-        )
-        .map_err(|e| format!("Failed to insert known address (json): {e}"))?;
+        conn.execute(crate::dbq!(db_contacts::Q_005), params![email, name])
+            .map_err(|e| format!("Failed to insert known address (json): {e}"))?;
     }
 
     Ok(())
@@ -274,22 +273,16 @@ fn insert_addresses_from_json(conn: &Connection, json: &str) -> Result<(), Strin
 
 #[allow(dead_code)]
 pub fn increment_contact_count(conn: &Connection, email: &str) -> Result<(), String> {
-    conn.execute(
-        crate::queries::sqlite::queries::db_contacts::Q_006,
-        params![email],
-    )
-    .map_err(|e| format!("Failed to increment contact count: {e}"))?;
+    conn.execute(crate::dbq!(db_contacts::Q_006), params![email])
+        .map_err(|e| format!("Failed to increment contact count: {e}"))?;
     Ok(())
 }
 
 #[allow(dead_code)]
 pub fn auto_add_contact(conn: &Connection, email: &str, name: &str) -> Result<(), String> {
     let id = Uuid::new_v4().to_string();
-    conn.execute(
-        crate::queries::sqlite::queries::db_contacts::Q_007,
-        params![id, email, name],
-    )
-    .map_err(|e| format!("Failed to auto-add contact: {e}"))?;
+    conn.execute(crate::dbq!(db_contacts::Q_007), params![id, email, name])
+        .map_err(|e| format!("Failed to auto-add contact: {e}"))?;
     Ok(())
 }
 
@@ -300,7 +293,7 @@ pub fn set_contact_photo(
     data: &[u8],
 ) -> Result<(), String> {
     conn.execute(
-        crate::queries::sqlite::queries::db_contacts::Q_008,
+        crate::dbq!(db_contacts::Q_008),
         params![contact_id, content_type, data],
     )
     .map_err(|e| format!("Failed to save contact photo: {e}"))?;
@@ -312,23 +305,20 @@ pub fn get_contact_photo(
     contact_id: &str,
 ) -> Result<Option<(String, Vec<u8>)>, String> {
     match conn.query_row(
-        crate::queries::sqlite::queries::db_contacts::Q_009,
+        crate::dbq!(db_contacts::Q_009),
         params![contact_id],
         |row| Ok((row.get(0)?, row.get(1)?)),
     ) {
         Ok(value) => Ok(Some(value)),
-        Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
+        Err(crate::db::pool::DbError::QueryReturnedNoRows) => Ok(None),
         Err(e) => Err(format!("Failed to load contact photo: {e}")),
     }
 }
 
 pub fn delete_contact_photo(conn: &Connection, contact_id: &str) -> Result<bool, String> {
-    conn.execute(
-        crate::queries::sqlite::queries::db_contacts::Q_010,
-        params![contact_id],
-    )
-    .map(|n| n > 0)
-    .map_err(|e| format!("Failed to delete contact photo: {e}"))
+    conn.execute(crate::dbq!(db_contacts::Q_010), params![contact_id])
+        .map(|n| n > 0)
+        .map_err(|e| format!("Failed to delete contact photo: {e}"))
 }
 
 #[cfg(test)]