Refactored db directory

service/src/auth/mod.rs

@@ -15,7 +15,8 @@ use siren::ServiceError;
 #[derive(Debug, Serialize, Deserialize)]
 struct TokenClaims {
     sub: String, // Subject
-    token_uuid: String, // Issuer
+    token_uuid: String, // Token UUID
+    iss: String, // Issuer
     exp: i64, // Expiration time
     iat: i64, // Issued At
     nbf: i64 // Not Before
@@ -73,6 +74,7 @@ pub fn generate_token(email: &str, ttl: i64, private_key: &str) -> Result<TokenD
   };
   let claims = TokenClaims {
     sub: token_details.email.clone(),
+    iss: "siren".to_string(),
     token_uuid: token_details.token_uuid.to_string(),
     exp: token_details.expires_in.unwrap(),
     iat: now.timestamp(),

service/src/auth/model.rs

@@ -6,7 +6,7 @@ use redis::Commands;
 use serde::{Serialize, Deserialize};
 use siren::ServiceError;
 
-use crate::db::schema::users;
+use crate::storage::{schema::users, connection};
 
 use super::{hash_password, verify_token};
 
@@ -27,6 +27,8 @@ impl RegisterUser {
       role: "user".to_string(),
       first_name: self.first_name,
       last_name: self.last_name,
+      updated_at: chrono::Utc::now().naive_utc(),
+      created_at: chrono::Utc::now().naive_utc(),
       verified: false,
     })
   }
@@ -46,12 +48,14 @@ pub struct QueryUser {
   pub role: String,
   pub first_name: String,
   pub last_name: String,
+  pub updated_at: chrono::NaiveDateTime,
+  pub created_at: chrono::NaiveDateTime,
   pub verified: bool,
 }
 
 impl QueryUser {
   pub fn get_by_email(email: &str) -> Result<QueryUser, ServiceError> {
-    let mut conn = crate::db::connection()?;
+    let mut conn = connection()?;
     // Check if the user exists by email, case insensitive
 
     let user = users::table
@@ -69,12 +73,14 @@ pub struct InsertUser {
   pub role: String,
   pub first_name: String,
   pub last_name: String,
+  pub updated_at: chrono::NaiveDateTime,
+  pub created_at: chrono::NaiveDateTime,
   pub verified: bool,
 }
 
 impl InsertUser {
   pub fn insert(user: Self) -> Result<QueryUser, ServiceError> {
-    let mut conn = crate::db::connection()?;
+    let mut conn = connection()?;
     let user = diesel::insert_into(users::table)
       .values(user)
       .get_result(&mut conn)?;
@@ -141,7 +147,7 @@ impl FromRequest for JwtAuth {
 
     let access_token_uuid = uuid::Uuid::parse_str(&access_token_details.token_uuid.to_string()).unwrap();
     
-    let mut conn = match crate::db::redis_connection() {
+    let mut conn = match crate::storage::redis_connection() {
       Ok(conn) => conn,
       Err(err) => {
         error!("Failed to get redis connection: {}", err);

service/src/auth/routes.rs

@@ -6,7 +6,7 @@ use redis::AsyncCommands;
 use serde::{Serialize, Deserialize};
 use siren::ServiceError;
 
-use crate::{auth::{LoginRequest, RegisterUser, InsertUser, QueryUser, verify_password, JwtAuth, verify_token, generate_access_token, generate_refresh_token}, db};
+use crate::{auth::{LoginRequest, RegisterUser, InsertUser, QueryUser, verify_password, JwtAuth, verify_token, generate_access_token, generate_refresh_token}, storage};
 
 #[post("/register")]
 async fn register(user: web::Json<RegisterUser>) -> HttpResponse {
@@ -58,7 +58,7 @@ async fn login(request: web::Json<LoginRequest>) -> HttpResponse {
         }
       };
 
-      let mut conn = match db::redis_async_connection().await {
+      let mut conn = match storage::redis_async_connection().await {
         Ok(conn) => conn,
         Err(err) => {
           error!("Failed to get redis connection: {}", err);
@@ -169,7 +169,7 @@ async fn refresh(req: HttpRequest) -> HttpResponse {
         }
       };
 
-      let mut conn = match db::redis_async_connection().await {
+      let mut conn = match storage::redis_async_connection().await {
         Ok(conn) => conn,
         Err(err) => {
           error!("Failed to get redis connection: {}", err);
@@ -292,7 +292,7 @@ async fn logout(req: HttpRequest, auth: JwtAuth) -> HttpResponse {
     Err(err) => return ResponseError::error_response(&err)
   };
 
-  let mut conn = match db::redis_async_connection().await {
+  let mut conn = match storage::redis_async_connection().await {
     Ok(conn) => conn,
     Err(err) => {
       error!("Failed to get redis connection: {}", err);