Merge pull request #6 from outof-coffee/development

feat(repo): Implement field tracking

Author: tsal

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dross-manager"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -20,3 +20,4 @@ http = "1.0.0"
 bytes = "1.5.0"
 tower = "0.4.13"
 log = "0.4.20"
+semver = "1.0.21"

src/endpoints.rs

@@ -4,9 +4,8 @@ use axum::extract::rejection::JsonRejection;
 use axum::http::StatusCode;
 use axum::Json;
 use axum::response::{IntoResponse, Response};
-use serde::Deserialize;
 use crate::DrossManagerState;
-use crate::faery::Faery;
+use crate::faery::{CreateFaeryRequest, Faery};
 use crate::repository::{Repository, RepositoryError};
 
 pub async fn list_faeries(State(state): State<Arc<DrossManagerState>>) -> Response {
@@ -24,7 +23,7 @@ pub async fn list_faeries(State(state): State<Arc<DrossManagerState>>) -> Respon
     }
 }
 
-pub async fn get_faery(State(state): State<Arc<DrossManagerState>>, Path(faery_id): Path<u32>) -> Response {
+pub async fn get_faery(State(state): State<Arc<DrossManagerState>>, Path(faery_id): Path<i64>) -> Response {
     log::info!("Getting faery {}", faery_id);
     let res = state.clone().faery_repository.get(faery_id).await;
     match res {
@@ -48,7 +47,7 @@ pub async fn get_faery(State(state): State<Arc<DrossManagerState>>, Path(faery_i
 
 pub async fn update_faery(
     State(state): State<Arc<DrossManagerState>>,
-    Path(faery_id): Path<u32>,
+    Path(faery_id): Path<i64>,
     payload: Result<Json<Faery>, JsonRejection>
 ) -> Response {
     match payload {
@@ -70,24 +69,20 @@ pub async fn update_faery(
         },
         Err(err) => {
             log::error!("Error updating faery {}: {:?}", faery_id, err);
-            return (StatusCode::BAD_REQUEST, Json(RepositoryError::from(err))).into_response();
+            let repo_error: RepositoryError = err.into();
+            return (StatusCode::BAD_REQUEST, Json(repo_error)).into_response();
         }
     }
 }
 
-#[derive(Deserialize, Debug)]
-pub struct CreateFaeryRequest {
-    pub name: String,
-    pub email: String,
-}
 pub async fn create_faery(
     State(state): State<Arc<DrossManagerState>>,
     payload: Result<Json<CreateFaeryRequest>, JsonRejection>
 ) -> Response {
     match payload {
         Ok(Json(payload)) => {
             log::info!("Creating faery: {:?}", payload);
-            let faery = Faery::new(payload.name, payload.email, false, 0, None);
+            let faery: Faery = payload.into();
             match state.clone().faery_repository.create(Some(faery.clone())).await {
                 Ok(_) => {
                     (StatusCode::CREATED, Json(faery)).into_response()
@@ -100,13 +95,14 @@ pub async fn create_faery(
         },
         Err(err) => {
             log::error!("Error creating faery: {:?}", err);
-            return (StatusCode::BAD_REQUEST, Json(RepositoryError::from(err))).into_response();
+            let repo_error: RepositoryError = err.into();
+            return (StatusCode::BAD_REQUEST, Json(repo_error)).into_response();
         }
     }
 
 }
 
-pub async fn delete_faery(State(state): State<Arc<DrossManagerState>>, Path(faery_id): Path<u32>) -> Response {
+pub async fn delete_faery(State(state): State<Arc<DrossManagerState>>, Path(faery_id): Path<i64>) -> Response {
     log::info!("Deleting faery {}", faery_id);
     match state.clone().faery_repository.delete(faery_id).await {
         Ok(_) => {

src/faery.rs

@@ -3,7 +3,7 @@ use libsql::{Row, params, Database};
 use serde::{Deserialize, Serialize};
 use tokio::sync::Mutex;
 use crate::dross::{DrossError, DrossHolder, DrossResult};
-use crate::repository::{Repository, RepositoryError, RepositoryResult};
+use crate::repository::{Repository, RepositoryError, RepositoryItem, RepositoryResult};
 
 #[derive(Clone)]
 pub struct FaeryRepository {
@@ -16,14 +16,59 @@ impl FaeryRepository {
             db,
         }
     }
+
+    // TODO: Secure this method
+    pub async fn update_auth_token(&self, id: i64, auth_token: String) -> RepositoryResult<()> {
+        let db = self.db.lock().await.connect().unwrap();
+        let result = db.execute("UPDATE faeries SET auth_token = ?1 WHERE id = ?2", params![auth_token, id]).await;
+        match result {
+            Ok(_) => Ok(()),
+            Err(_) => Err(RepositoryError::Other),
+        }
+    }
+}
+
+impl RepositoryItem for Faery {
+    fn masked_columns(is_admin: bool) -> Vec<String> {
+        let mut columns = vec!["auth_token".to_string()];
+        if !is_admin {
+            columns.push("email".to_string());
+        }
+        columns
+    }
+
+    fn saved_columns() -> Vec<String> {
+        // get all columns
+        let columns = Faery::all_columns();
+        // filter out masked columns, assuming is_admin is true
+        let masked_columns = Faery::masked_columns(true);
+        columns.into_iter().filter(|c| !masked_columns.contains(c)).collect()
+    }
+
+    fn all_columns() -> Vec<String> {
+        vec![
+            "id".to_string(),
+            "name".to_string(),
+            "is_admin".to_string(),
+            "email".to_string(),
+            "auth_token".to_string(),
+            "dross".to_string(),
+        ]
+    }
+
+    fn table_name() -> String {
+        "faeries".to_string()
+    }
+
 }
 
 #[shuttle_runtime::async_trait]
 // Mark: Repository
 impl Repository for FaeryRepository {
     type Item = Faery;
+    type RowIdentifier = i64;
 
-    async fn create(&self, faery: Option<Faery>) -> RepositoryResult<()> {
+    async fn create(&self, faery: Option<Faery>) -> RepositoryResult<i64> {
         match faery {
             Some(faery) => {
                 self.save(faery).await
@@ -32,7 +77,7 @@ impl Repository for FaeryRepository {
         }
     }
 
-    async fn save(&self, faery: Faery) -> RepositoryResult<()> {
+    async fn save(&self, faery: Faery) -> RepositoryResult<i64> {
         let db = self.db.lock().await.connect().unwrap();
         let result = match faery.id {
             Some(id) => {
@@ -45,38 +90,13 @@ impl Repository for FaeryRepository {
             },
         };
         match result {
-            Ok(_) => Ok(()),
-            Err(_) => Err(RepositoryError::Other),
-        }
-    }
-
-    async fn create_table(&self) -> RepositoryResult<()> {
-        let db = self.db.lock().await.connect().unwrap();
-        let result = db.execute(
-            r#"CREATE TABLE IF NOT EXISTS faeries (
-    id INTEGER PRIMARY KEY,
-    name VARCHAR(255) NOT NULL,
-    is_admin BOOLEAN NOT NULL,
-    email VARCHAR(255) NOT NULL,
-    dross INTEGER
-)"#, ()).await;
-        match result {
-            Ok(_) => Ok(()),
-            Err(_) => Err(RepositoryError::Other),
-        }
-    }
-
-    async fn drop_table(&self) -> RepositoryResult<()> {
-        let db = self.db.lock().await.connect().unwrap();
-        let result = db.execute("DROP TABLE IF EXISTS faeries", ()).await;
-        match result {
-            Ok(_) => Ok(()),
+            Ok(_) => Ok(db.last_insert_rowid()),
             Err(_) => Err(RepositoryError::Other),
         }
     }
 
     // Mark: Faery
-    async fn get(&self, id: u32) -> RepositoryResult<Faery> {
+    async fn get(&self, id: i64) -> RepositoryResult<Faery> {
         let db = self.db.lock().await.connect().unwrap();
         let mut stmt = db
             .prepare("SELECT * FROM faeries WHERE id = ?1")
@@ -102,6 +122,7 @@ impl Repository for FaeryRepository {
                 return Err(RepositoryError::Other)
             },
         };
+
         let mut faeries: Vec<Faery> = Vec::new();
         while let Ok(result_row) = res.next().await {
             match result_row {
@@ -114,7 +135,7 @@ impl Repository for FaeryRepository {
         Ok(faeries)
     }
 
-    async fn delete(&self, id: u32) -> RepositoryResult<()> {
+    async fn delete(&self, id: i64) -> RepositoryResult<()> {
         let db = self.db.lock().await.connect().unwrap();
         let result = db.execute("DELETE FROM faeries WHERE id = ?1", [id]).await;
         match result {
@@ -123,20 +144,40 @@ impl Repository for FaeryRepository {
         }
     }
 
-    fn table_name() -> String {
-        "faeries".to_string()
+    async fn create_table(&self) -> RepositoryResult<()> {
+        let db = self.db.lock().await.connect().unwrap();
+        let result = db.execute(
+            r#"CREATE TABLE IF NOT EXISTS faeries (
+    id INTEGER PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    is_admin BOOLEAN NOT NULL,
+    email VARCHAR(255) NOT NULL,
+    dross INTEGER
+)"#, ()).await;
+        match result {
+            Ok(_) => Ok(()),
+            Err(_) => Err(RepositoryError::Other),
+        }
+    }
+
+    async fn drop_table(&self) -> RepositoryResult<()> {
+        let db = self.db.lock().await.connect().unwrap();
+        let result = db.execute("DROP TABLE IF EXISTS faeries", ()).await;
+        match result {
+            Ok(_) => Ok(()),
+            Err(_) => Err(RepositoryError::Other),
+        }
     }
 }
 
 // Faery represents the user of the application.
 // It has the name of the user, their email, an authentication token, and a count of their dross.
 #[derive(Debug, Deserialize, Serialize)]
 pub struct Faery {
-    pub(crate) id: Option<u32>,
+    pub(crate) id: Option<i64>,
     pub name: String,
     pub email: String,
     pub is_admin: bool,
-    #[serde(skip_serializing)]
     pub auth_token: Option<String>,
     pub dross: u32,
 }
@@ -145,12 +186,13 @@ pub struct Faery {
 impl Faery {
     // This is a method that creates a new Faery.
     // It takes a name and an email and returns a Faery.
-    pub fn new(name: String, email: String, is_admin: bool, dross: u32, id: Option<u32>) -> Faery {
+    pub fn new(name: String, email: String, is_admin: bool, dross: u32, id: Option<i64>) -> Faery {
         Faery {
             id,
             name,
             email,
             is_admin,
+            // TODO: Implement static method for inflating from auth_token claims
             auth_token: None,
             dross,
         }
@@ -246,3 +288,16 @@ impl DrossHolder for Faery {
         Ok(self.dross)
     }
 }
+
+
+#[derive(Deserialize, Debug)]
+pub struct CreateFaeryRequest {
+    pub name: String,
+    pub email: String,
+}
+
+impl From<CreateFaeryRequest> for Faery {
+    fn from(req: CreateFaeryRequest) -> Self {
+        Faery::new(req.name, req.email, false, 0, None)
+    }
+}

src/main.rs

@@ -2,18 +2,19 @@ mod faery;
 mod dross;
 mod endpoints;
 mod repository;
+mod migrations;
+mod version;
 
 use std::net::SocketAddr;
 use axum::{routing::get, Router};
 use tower_http::services::ServeDir;
 use libsql::Builder;
 use std::sync::Arc;
 use tokio::sync::Mutex;
-use repository::Repository;
 use http::{Method};
 
 use tower::{ServiceBuilder};
-use tower_http::cors::{Any, CorsLayer};
+use tower_http::cors::{CorsLayer};
 
 
 pub struct DrossManagerService {
@@ -47,15 +48,16 @@ async fn axum(
     });
 
     // TODO: Handle errors
-    log::info!("Creating table");
-    state.faery_repository.create_table().await.unwrap();
+    let manager = migrations::Manager::new(db.clone(), state.faery_repository.clone());
+    let needs_migration = manager.needs_migration().await;
+    if needs_migration {
+        log::info!("Running migrations");
+        manager.migrate().await.unwrap();
+    }
 
     log::info!("Creating CORS middleware");
     let cors = CorsLayer::new()
-        // allow `GET` and `POST` when accessing the resource
-        .allow_methods([Method::GET, Method::POST])
-        // allow requests from any origin
-        .allow_origin(Any);
+        .allow_methods([Method::GET, Method::POST, Method::PUT, Method::DELETE]);
 
     log::info!("Creating router");
     let router = Router::new()