From 0adf5a093494bdb7f5d5c0f12913133e333ddfad Mon Sep 17 00:00:00 2001
From: Joris
Date: Fri, 31 Jan 2025 22:28:53 +0100
Subject: Migrate to tokio_rusqlite

---
 src/db/users.rs | 180 ++++++++++++++++++++++++++++++--------------------------
 1 file changed, 95 insertions(+), 85 deletions(-)

(limited to 'src/db/users.rs')

diff --git a/src/db/users.rs b/src/db/users.rs
index f463421..8b21ff4 100644
--- a/src/db/users.rs
+++ b/src/db/users.rs
@@ -1,24 +1,30 @@
-use sqlx::error::Error;
-use sqlx::sqlite::{SqlitePool, SqliteRow};
-use sqlx_core::row::Row;
+use tokio_rusqlite::{named_params, Connection, Row};
 
+use crate::db::utils;
 use crate::model::user::User;
 
-pub async fn list(pool: &SqlitePool) -> Vec<User> {
-    let res = sqlx::query_as::<_, User>(
-        r#"
-SELECT
-    id,
-    name,
-    email
-FROM
-    users
-ORDER BY
-    name
-    "#,
-    )
-    .fetch_all(pool)
-    .await;
+fn row_to_user(row: &Row) -> Result<User, rusqlite::Error> {
+    Ok(User {
+        id: row.get(0)?,
+        name: row.get(1)?,
+        email: row.get(2)?,
+    })
+}
+
+pub async fn list(conn: &Connection) -> Vec<User> {
+    let query = r#"SELECT id, name, email FROM users ORDER BY name"#;
+
+    let res = conn
+        .call(move |conn| {
+            let mut stmt = conn.prepare(query)?;
+
+            let users = stmt
+                .query_map([], row_to_user)?
+                .collect::<Result<Vec<User>, _>>()?;
+
+            Ok(users)
+        })
+        .await;
 
     match res {
         Ok(users) => users,
@@ -30,25 +36,30 @@ ORDER BY
 }
 
 pub async fn set_login_token(
-    pool: &SqlitePool,
+    conn: &Connection,
     email: String,
     login_token: String,
 ) -> bool {
-    let res = sqlx::query(
-        r#"
-UPDATE
-    users
-SET
-    login_token = ?,
-    updated_at = datetime()
-WHERE
-    email = ?
-    "#,
-    )
-    .bind(login_token)
-    .bind(email)
-    .execute(pool)
-    .await;
+    let query = r#"
+        UPDATE users
+        SET
+            login_token = :login_token,
+            updated_at = datetime()
+        WHERE
+            email = :email
+    "#;
+
+    let res = conn
+        .call(move |conn| {
+            Ok(conn.execute(
+                query,
+                named_params![
+                    ":login_token": login_token,
+                    ":email": email
+                ],
+            )?)
+        })
+        .await;
 
     match res {
         Ok(_) => true,
@@ -59,21 +70,18 @@ WHERE
     }
 }
 
-pub async fn remove_login_token(pool: &SqlitePool, id: i64) -> bool {
-    let res = sqlx::query(
-        r#"
-UPDATE
-    users
-SET
-    login_token = NULL,
-    updated_at = datetime()
-WHERE
-    id = ?
-    "#,
-    )
-    .bind(id)
-    .execute(pool)
-    .await;
+pub async fn remove_login_token(conn: &Connection, id: i64) -> bool {
+    let query = r#"
+        UPDATE users
+        SET
+            login_token = NULL,
+            updated_at = datetime()
+        WHERE id = :id
+    "#;
+
+    let res = conn
+        .call(move |conn| Ok(conn.execute(query, named_params![":id": id])?))
+        .await;
 
     match res {
         Ok(_) => true,
@@ -85,59 +93,61 @@ WHERE
 }
 
 pub async fn get_by_login_token(
-    pool: &SqlitePool,
+    conn: &Connection,
     login_token: String,
 ) -> Option<User> {
-    let res = sqlx::query_as::<_, User>(
-        r#"
-SELECT
-    id,
-    name,
-    email
-FROM
-    users
-WHERE
-    login_token = ?
-    "#,
-    )
-    .bind(login_token)
-    .fetch_one(pool)
-    .await;
+    let query = r#"
+        SELECT
+            id,
+            name,
+            email
+        FROM users
+        WHERE login_token = :login_token
+    "#;
+
+    let res = conn
+        .call(move |conn| {
+            let mut stmt = conn.prepare(query)?;
+            let mut iter = stmt.query_map(
+                named_params![":login_token": login_token],
+                row_to_user,
+            )?;
+            utils::one(&mut iter)
+        })
+        .await;
 
     match res {
         Ok(user) => Some(user),
-        Err(Error::RowNotFound) => None,
         Err(err) => {
-            log::error!("Error getting user from login token: {:?}", err);
+            log::error!("Error getting user from login_token: {err:?}");
             None
         }
     }
 }
 
 pub async fn get_password_hash(
-    pool: &SqlitePool,
+    conn: &Connection,
     email: String,
 ) -> Option<String> {
-    let res = sqlx::query(
-        r#"
-SELECT
-    password
-FROM
-    users
-WHERE
-    email = ?
-    "#,
-    )
-    .bind(email)
-    .map(|row: SqliteRow| row.get("password"))
-    .fetch_one(pool)
-    .await;
+    let query = r#"
+        SELECT password
+        FROM users
+        WHERE email = :email
+    "#;
+
+    let res = conn
+        .call(move |conn| {
+            let mut stmt = conn.prepare(query)?;
+            let mut iter = stmt
+                .query_map(named_params![":email": email], |row| row.get(0))?;
+            utils::one::<String, _>(&mut iter)
+        })
+        .await;
 
     match res {
-        Ok(hash) => Some(hash),
-        Err(Error::RowNotFound) => None,
+        Ok(hash) => Some(hash.clone()),
         Err(err) => {
-            log::error!("Error getting password hash: {:?}", err);
+            log::error!("Error listing users: {:?}", err);
             None
         }
     }
-- 
cgit v1.2.3