Add comprehensive tests for mentor repository and authentication

- Implemented tests for creating, retrieving, updating, and deleting mentors in `mentor_repository_test.rs`.
- Added tests for user authentication, including successful login, invalid email formats, and inactive users in `auth_login_tests.rs`.
- Created a mock test environment setup in `mock_test.rs` to facilitate database operations during tests.
- Updated module structure to include new test files for mentors and authentication.
- Ensured cleanup of the database after tests to maintain isolation and prevent side effects.

imphnen-iam/Cargo.toml

@@ -4,9 +4,9 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-imphnen-libs = { version = "0.1.0", path = "../imphnen-libs" }
-imphnen-utils = { version = "0.1.0", path = "../imphnen-utils" }
-imphnen-entities = { version = "0.1.0", path = "../imphnen-entities" }
+imphnen-libs.workspace = true
+imphnen-utils.workspace = true
+imphnen-entities.workspace = true
 axum.workspace = true
 serde.workspace = true
 serde_json.workspace = true
@@ -22,3 +22,13 @@ chrono.workspace = true
 anyhow.workspace = true
 tower-http.workspace = true
 utoipa-swagger-ui.workspace = true
+strum.workspace = true
+strum_macros.workspace = true
+log.workspace = true
+once_cell.workspace = true
+tracing.workspace = true
+uuid.workspace = true
+
+[dev-dependencies]
+dotenvy.workspace = true
+http-body-util.workspace = true

imphnen-iam/src/lib.rs

@@ -1,34 +1,6 @@
-use ::surrealdb::Uuid;
-use imphnen_entities::*;
-use imphnen_libs::*;
-use imphnen_utils::*;
-
 pub mod v1;
 
 pub use imphnen_entities::*;
 pub use imphnen_libs::*;
 pub use imphnen_utils::*;
 pub use v1::*;
-
-pub fn create_test_user(
-	email: &str,
-	fullname: &str,
-	is_active: bool,
-	role_id: &str,
-) -> UsersSchema {
-	UsersSchema {
-		id: make_thing("app_users", &Uuid::new_v4().to_string()),
-		email: email.to_string(),
-		fullname: format!("Randomize {} {}", fullname, rand::random::<u32>()),
-		password: hash_password("secret").unwrap(),
-		is_deleted: false,
-		avatar: None,
-		phone_number: "081234567890".to_string(),
-		is_active,
-		gender: None,
-		birthdate: None,
-		role: make_thing("app_roles", role_id),
-		created_at: get_iso_date(),
-		updated_at: get_iso_date(),
-	}
-}

imphnen-iam/src/v1/auth/auth_controller.rs

@@ -2,9 +2,9 @@ use super::{
 	AuthLoginRequestDto, AuthRefreshTokenRequestDto, AuthRegisterRequestDto,
 	AuthResendOtpRequestDto, AuthService, AuthVerifyEmailRequestDto,
 };
-use crate::{v1::AuthLoginResponsetDto, AppState};
+use crate::{AppState, v1::AuthLoginResponsetDto};
 use crate::{AuthNewPasswordRequestDto, MessageResponseDto, ResponseSuccessDto};
-use axum::{response::IntoResponse, Extension, Json};
+use axum::{Extension, Json, response::IntoResponse};
 
 #[utoipa::path(
     post,
@@ -23,6 +23,24 @@ pub async fn post_login(
 	AuthService::mutation_login(payload, &state).await
 }
 
+#[utoipa::path(
+    post,
+    path = "/v1/auth/login-mentor",
+    request_body = AuthLoginRequestDto,
+    responses(
+        (status = 200, description = "Mentor login successful", body = ResponseSuccessDto<AuthLoginResponsetDto>),
+        (status = 401, description = "Mentor login failed", body = MessageResponseDto),
+        (status = 403, description = "Forbidden - Not a mentor", body = MessageResponseDto)
+    ),
+    tag = "Authentication"
+)]
+pub async fn post_login_mentor(
+	Extension(state): Extension<AppState>,
+	Json(payload): Json<AuthLoginRequestDto>,
+) -> impl IntoResponse {
+	AuthService::mutation_mentor_login(payload, &state).await
+}
+
 #[utoipa::path(
     post,
     path = "/v1/auth/register",

imphnen-iam/src/v1/auth/auth_dto.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 use validator::{Validate, ValidationError};
 
-fn validate_password_complexity(password: &str) -> Result<(), ValidationError> {
+pub fn validate_password_complexity(password: &str) -> Result<(), ValidationError> {
 	let has_uppercase = password.chars().any(|c| c.is_ascii_uppercase());
 	let has_lowercase = password.chars().any(|c| c.is_ascii_lowercase());
 	let has_digit = password.chars().any(|c| c.is_ascii_digit());
@@ -117,3 +117,8 @@ pub struct AuthSetNewPasswordRequestDto {
 	))]
 	pub password: String,
 }
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct UserCacheSchema {
+	pub email: String,
+	pub permissions: Vec<String>,
+}

imphnen-iam/src/v1/auth/auth_repository.rs

@@ -1,7 +1,12 @@
 use super::AuthOtpSchema;
-use crate::{AppState, ResourceEnum, UsersDetailQueryDto, make_thing};
+use super::UserCacheSchema;
+use crate::{
+	AppState, PermissionsQueryDto, ResourceEnum, RolesDetailQueryDto,
+	UsersDetailQueryDto,
+};
 use anyhow::{Result, anyhow, bail};
 use chrono::{Duration, Utc};
+use surrealdb::sql::Thing;
 
 pub struct AuthRepository<'a> {
 	pub state: &'a AppState,
@@ -18,20 +23,26 @@ impl<'a> AuthRepository<'a> {
 		}
 		let table = ResourceEnum::UsersCache.to_string();
 		let user_id = user.email.clone();
-		let id = make_thing(&table, &user_id);
-		let _ = self
+		let permissions: Vec<String> =
+			user.role.permissions.into_iter().map(|p| p.name).collect();
+		let user_cache = UserCacheSchema {
+			email: user_id.clone(),
+			permissions,
+		};
+
+		let _record: Option<UserCacheSchema> = self
 			.state
 			.surrealdb_mem
-			.delete::<Option<UsersDetailQueryDto>>((table.clone(), user_id.clone()))
+			.delete::<Option<UserCacheSchema>>((table.clone(), user_id.clone()))
 			.await?;
-		let mut user_to_store = user.clone();
-		user_to_store.id = id.clone();
-		let record: Option<UsersDetailQueryDto> = self
+
+		let record: Option<UserCacheSchema> = self
 			.state
 			.surrealdb_mem
 			.create((table, user_id))
-			.content(user_to_store)
+			.content(user_cache)
 			.await?;
+
 		match record {
 			Some(_) => Ok("Success store user data".to_string()),
 			None => bail!("Failed store user data"),
@@ -42,13 +53,54 @@ impl<'a> AuthRepository<'a> {
 		&self,
 		email: String,
 	) -> Result<UsersDetailQueryDto> {
-		let user: Option<UsersDetailQueryDto> = self
+		let user_cache: Option<UserCacheSchema> = self
 			.state
 			.surrealdb_mem
-			.select((ResourceEnum::UsersCache.to_string(), email))
+			.select((ResourceEnum::UsersCache.to_string(), email.clone()))
 			.await?;
-		match user {
-			Some(u) => Ok(u),
+
+		match user_cache {
+			Some(cache) => {
+				let permissions_query_dto: Vec<PermissionsQueryDto> = cache
+					.permissions
+					.into_iter()
+					.map(|name| PermissionsQueryDto {
+						id: Thing::from((
+							"app_permissions".to_string(),
+							surrealdb::sql::Id::rand(),
+						)),
+						name,
+						created_at: None,
+						updated_at: None,
+					})
+					.collect();
+
+				let role_detail_query_dto = RolesDetailQueryDto {
+					id: Thing::from(("app_roles".to_string(), surrealdb::sql::Id::rand())),
+					name: "CachedRole".to_string(),
+					permissions: permissions_query_dto,
+					is_deleted: false,
+					created_at: None,
+					updated_at: None,
+				};
+
+				Ok(UsersDetailQueryDto {
+					id: Thing::from(("app_users".to_string(), email.clone())),
+					fullname: "Cached User".to_string(),
+					email: cache.email,
+					avatar: None,
+					phone_number: String::new(),
+					is_active: true,
+					is_deleted: false,
+					gender: None,
+					birthdate: None,
+					password: String::new(),
+					role: role_detail_query_dto,
+					created_at: String::new(),
+					updated_at: String::new(),
+					mentor_id: None,
+				})
+			}
 			None => bail!("No stored user data found"),
 		}
 	}
@@ -59,7 +111,6 @@ impl<'a> AuthRepository<'a> {
 			.surrealdb_mem
 			.delete((ResourceEnum::UsersCache.to_string(), email))
 			.await?;
-		dbg!(record.clone());
 		match record {
 			Some(_) => Ok("Success delete stored user".to_string()),
 			None => bail!("Failed delete stored user"),

imphnen-iam/src/v1/auth/auth_service.rs

@@ -13,6 +13,7 @@ use crate::{
 };
 use axum::{http::StatusCode, response::Response};
 use surrealdb::Uuid;
+use tracing::error;
 
 pub struct AuthService;
 
@@ -49,7 +50,11 @@ impl AuthService {
 
 				let access_token = match encode_access_token(payload.email.clone()) {
 					Ok(token) => token,
-					Err(_) => {
+					Err(_e) => {
+						error!(
+							"Failed to generate access token for {}: {}",
+							payload.email, _e
+						);
 						return common_response(
 							StatusCode::INTERNAL_SERVER_ERROR,
 							"Failed to generate access token",
@@ -59,7 +64,11 @@ impl AuthService {
 
 				let refresh_token = match encode_refresh_token(payload.email.clone()) {
 					Ok(token) => token,
-					Err(_) => {
+					Err(_e) => {
+						error!(
+							"Failed to generate refresh token for {}: {}",
+							payload.email, _e
+						);
 						return common_response(
 							StatusCode::INTERNAL_SERVER_ERROR,
 							"Failed to generate refresh token",
@@ -77,13 +86,116 @@ impl AuthService {
 					},
 				};
 
-				if let Err(_err) = auth_repo.query_store_user(user).await {
-					return common_response(StatusCode::BAD_REQUEST, "User already login");
+				if let Err(err_store) = auth_repo.query_store_user(user.clone()).await {
+					error!(
+						"Failed to store user cache for {}: {}",
+						user.email, err_store
+					);
+					return common_response(
+						StatusCode::BAD_REQUEST,
+						"User already login or failed to cache",
+					);
 				}
-
 				success_response(response)
 			}
-			Err(err) => common_response(StatusCode::UNAUTHORIZED, &err.to_string()),
+			Err(err_find) => {
+				common_response(StatusCode::UNAUTHORIZED, &err_find.to_string())
+			}
+		}
+	}
+
+	pub async fn mutation_mentor_login(
+		payload: AuthLoginRequestDto,
+		state: &AppState,
+	) -> Response {
+		if let Err((status, message)) = validate_request(&payload) {
+			return common_response(status, &message);
+		}
+
+		let user_repo = UsersRepository::new(state);
+		let auth_repo = AuthRepository::new(state);
+
+		match user_repo.query_user_by_email(payload.email.clone()).await {
+			Ok(user) => {
+				let is_password_correct =
+					verify_password(&payload.password, &user.password).unwrap_or(false);
+
+				if !is_password_correct {
+					return common_response(
+						StatusCode::BAD_REQUEST,
+						"Email or password not correct",
+					);
+				}
+
+				if !user.is_active {
+					return common_response(
+						StatusCode::BAD_REQUEST,
+						"Account not active, please verify your email",
+					);
+				}
+
+				let user_detail = UsersDetailItemDto::from(&user);
+
+				if user_detail.role.name != RolesEnum::Mentor.to_string() {
+					return common_response(
+						StatusCode::FORBIDDEN,
+						"User does not have mentor privileges",
+					);
+				}
+
+				let access_token = match encode_access_token(payload.email.clone()) {
+					Ok(token) => token,
+					Err(_e) => {
+						error!(
+							"Failed to generate access token for {}: {}",
+							payload.email, _e
+						);
+						return common_response(
+							StatusCode::INTERNAL_SERVER_ERROR,
+							"Failed to generate access token",
+						);
+					}
+				};
+
+				let refresh_token = match encode_refresh_token(payload.email.clone()) {
+					Ok(token) => token,
+					Err(_e) => {
+						error!(
+							"Failed to generate refresh token for {}: {}",
+							payload.email, _e
+						);
+						return common_response(
+							StatusCode::INTERNAL_SERVER_ERROR,
+							"Failed to generate refresh token",
+						);
+					}
+				};
+
+				let response = ResponseSuccessDto {
+					data: AuthLoginResponsetDto {
+						user: UsersDetailItemDto::from(&user),
+						token: TokenDto {
+							access_token,
+							refresh_token,
+						},
+					},
+				};
+
+				if let Err(err_store) = auth_repo.query_store_user(user.clone()).await {
+					error!(
+						"Failed to store user cache for {}: {}",
+						user.email, err_store
+					);
+					return common_response(
+						StatusCode::BAD_REQUEST,
+						"User already login or failed to cache",
+					);
+				}
+				success_response(response)
+			}
+			Err(err_find) => {
+				common_response(StatusCode::UNAUTHORIZED, &err_find.to_string())
+			}
 		}
 	}
 
@@ -102,7 +214,10 @@ impl AuthService {
 			.await
 		{
 			Ok(role) => role,
-			Err(_) => return common_response(StatusCode::BAD_REQUEST, "Role Not Found"),
+			Err(_e) => {
+				error!("Failed to retrieve User role during registration: {}", _e);
+				return common_response(StatusCode::BAD_REQUEST, "Role Not Found");
+			}
 		};
 		if user_repo
 			.query_user_by_email(payload.email.clone())
@@ -113,7 +228,11 @@ impl AuthService {
 		}
 		let hashed_password = match hash_password(&payload.password) {
 			Ok(hash) => hash,
-			Err(_) => {
+			Err(_e) => {
+				error!(
+					"Failed to hash password during registration for {}: {}",
+					payload.email, _e
+				);
 				return common_response(
 					StatusCode::INTERNAL_SERVER_ERROR,
 					"Failed to hash password",
@@ -121,27 +240,34 @@ impl AuthService {
 			}
 		};
 		let new_user = AuthRegisterRequestDto {
-			email: payload.email,
+			email: payload.email.clone(),
 			password: hashed_password,
 			fullname: payload.fullname,
 			phone_number: payload.phone_number,
 		};
 		let otp = generate_otp::OtpManager::generate_otp();
-		match auth_repo
-			.query_store_otp(new_user.email.clone(), otp.clone())
-			.await
-		{
+		match auth_repo.query_store_otp(new_user.email.clone(), otp).await {
 			Ok(_) => {
-				let message = format!("your otp code is {}", otp);
-				if let Err(err) = send_email(&new_user.email, "OTP Verification", &message) {
+				let message = format!("your otp code is {otp}");
+				if let Err(err_send) =
+					send_email(&new_user.email, "OTP Verification", &message)
+				{
+					error!(
+						"Failed to send OTP email to {}: {}",
+						new_user.email, err_send
+					);
 					return common_response(
 						StatusCode::INTERNAL_SERVER_ERROR,
-						&err.to_string(),
+						&err_send.to_string(),
 					);
 				}
 			}
-			Err(err) => {
-				return common_response(StatusCode::INTERNAL_SERVER_ERROR, &err.to_string());
+			Err(err_store) => {
+				error!("Failed to store OTP for {}: {}", new_user.email, err_store);
+				return common_response(
+					StatusCode::INTERNAL_SERVER_ERROR,
+					&err_store.to_string(),
+				);
 			}
 		}
 		let role_thing = make_thing(&ResourceEnum::Roles.to_string(), &role.id);
@@ -159,13 +285,15 @@ impl AuthService {
 				created_at: get_iso_date(),
 				updated_at: get_iso_date(),
 				role: role_thing,
+				is_active: true,
 				..Default::default()
 			})
 			.await
 		{
 			Ok(msg) => common_response(StatusCode::CREATED, &msg),
-			Err(err) => {
-				common_response(StatusCode::INTERNAL_SERVER_ERROR, &err.to_string())
+			Err(err_create) => {
+				error!("Failed to create user {}: {}", new_user.email, err_create);
+				common_response(StatusCode::INTERNAL_SERVER_ERROR, &err_create.to_string())
 			}
 		}
 	}
@@ -188,13 +316,22 @@ impl AuthService {
 		let auth_repo = AuthRepository::new(state);
 		let _ = auth_repo.query_get_stored_otp(payload.email.clone()).await;
 		let otp = generate_otp::OtpManager::generate_otp();
-		let message = format!("Your OTP code is {}", otp);
+		let message = format!("Your OTP code is {otp}");
 		match auth_repo.query_store_otp(payload.email.clone(), otp).await {
 			Ok(_) => match send_email(&payload.email, "OTP Verification", &message) {
 				Ok(_) => common_response(StatusCode::OK, "OTP resent successfully"),
-				Err(err) => common_response(StatusCode::BAD_REQUEST, &err.to_string()),
+				Err(err_send) => {
+					error!(
+						"Failed to send OTP email to {}: {}",
+						payload.email, err_send
+					);
+					common_response(StatusCode::BAD_REQUEST, &err_send.to_string())
+				}
 			},
-			Err(err) => common_response(StatusCode::BAD_REQUEST, &err.to_string()),
+			Err(err_store) => {
+				error!("Failed to store OTP for {}: {}", payload.email, err_store);
+				common_response(StatusCode::BAD_REQUEST, &err_store.to_string())
+			}
 		}
 	}
 
@@ -206,13 +343,14 @@ impl AuthService {
 		}
 		let email = match decode_refresh_token(&payload.refresh_token) {
 			Ok(token) => token.claims.sub,
-			Err(_) => {
+			Err(_e) => {
 				return common_response(StatusCode::UNAUTHORIZED, "Invalid refresh token");
 			}
 		};
 		let access_token = match encode_access_token(email.clone()) {
 			Ok(token) => token,
-			Err(_) => {
+			Err(_e) => {
+				error!("Failed to generate access token for {}: {}", email, _e);
 				return common_response(
 					StatusCode::INTERNAL_SERVER_ERROR,
 					"Failed to generate access token",
@@ -221,7 +359,8 @@ impl AuthService {
 		};
 		let refresh_token = match encode_refresh_token(email.clone()) {
 			Ok(token) => token,
-			Err(_) => {
+			Err(_e) => {
+				error!("Failed to generate refresh token for {}: {}", email, _e);
 				return common_response(
 					StatusCode::INTERNAL_SERVER_ERROR,
 					"Failed to generate refresh token",
@@ -248,16 +387,27 @@ impl AuthService {
 		let user_result = user_repo.query_user_by_email(payload.email.clone()).await;
 		let user = match user_result {
 			Ok(user) => user,
-			Err(err) if err.to_string().contains("User not found") => {
+			Err(err_find) if err_find.to_string().contains("User not found") => {
 				return common_response(StatusCode::BAD_REQUEST, "User not found");
 			}
-			Err(err) => {
-				return common_response(StatusCode::INTERNAL_SERVER_ERROR, &err.to_string());
+			Err(err_other) => {
+				error!(
+					"Error finding user for forgot password {}: {}",
+					payload.email, err_other
+				);
+				return common_response(
+					StatusCode::INTERNAL_SERVER_ERROR,
+					&err_other.to_string(),
+				);
 			}
 		};
-		let token = match encode_reset_password_token(user.email) {
+		let token = match encode_reset_password_token(user.email.clone()) {
 			Ok(token) => token,
-			Err(_) => {
+			Err(_e) => {
+				error!(
+					"Failed to generate reset password token for {}: {}",
+					user.email, _e
+				);
 				return common_response(
 					StatusCode::INTERNAL_SERVER_ERROR,
 					"Failed to generate access token",
@@ -267,12 +417,17 @@ impl AuthService {
 		let env = Env::new();
 		let fe_url = env.fe_url;
 		let message = format!(
-			"You have requested a password reset. Please click the link below to continue: {}/auth/reset-password?token={}",
-			fe_url, token
+			"You have requested a password reset. Please click the link below to continue: {fe_url}/auth/reset-password?token={token}"
 		);
 		match send_email(&payload.email, "Reset Password Request", &message) {
 			Ok(_) => common_response(StatusCode::OK, "Reset Password request send"),
-			Err(err) => common_response(StatusCode::BAD_REQUEST, &err.to_string()),
+			Err(err_send) => {
+				error!(
+					"Failed to send reset password email to {}: {}",
+					payload.email, err_send
+				);
+				common_response(StatusCode::BAD_REQUEST, &err_send.to_string())
+			}
 		}
 	}
 
@@ -288,33 +443,38 @@ impl AuthService {
 		let email = payload.email.clone();
 		let user = match user_repo.query_user_by_email(email.clone()).await {
 			Ok(user) if !user.is_deleted => user,
-			_ => return common_response(StatusCode::NOT_FOUND, "User not found"),
+			_ => {
+				return common_response(StatusCode::NOT_FOUND, "User not found");
+			}
 		};
 		let patch = UsersSchema {
 			id: user.id.clone(),
 			is_active: true,
-			..UsersSchema::from(user)
+			..UsersSchema::from(user.clone())
 		};
 		match auth_repo.query_get_stored_otp(email.clone()).await {
 			Ok(stored_otp) => match stored_otp == payload.otp {
 				true => match user_repo.query_update_user(patch).await {
-					Ok(_) => match auth_repo.query_delete_stored_otp(email).await {
+					Ok(_) => match auth_repo.query_delete_stored_otp(email.clone()).await {
 						Ok(_) => common_response(StatusCode::OK, "Email verified successfully"),
-						Err(e) => {
-							common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string())
+						Err(e_del) => {
+							error!("Failed to delete OTP for {}: {}", email, e_del);
+							common_response(StatusCode::INTERNAL_SERVER_ERROR, &e_del.to_string())
 						}
 					},
-					Err(err) => common_response(StatusCode::BAD_REQUEST, &err.to_string()),
+					Err(err_update) => {
+						common_response(StatusCode::BAD_REQUEST, &err_update.to_string())
+					}
 				},
-				false => match auth_repo.query_delete_stored_otp(email).await {
+				false => match auth_repo.query_delete_stored_otp(email.clone()).await {
 					Ok(_) => common_response(StatusCode::BAD_REQUEST, "Failed to verify OTP"),
-					Err(e) => common_response(
+					Err(e_del_mismatch) => common_response(
 						StatusCode::INTERNAL_SERVER_ERROR,
-						&format!("Failed to delete OTP: {}", e),
+						&format!("Failed to delete OTP: {e_del_mismatch}"),
 					),
 				},
 			},
-			Err(err) => common_response(StatusCode::BAD_REQUEST, &err.to_string()),
+			Err(err_get) => common_response(StatusCode::BAD_REQUEST, &err_get.to_string()),
 		}
 	}
 
@@ -327,14 +487,15 @@ impl AuthService {
 		}
 		let repo = UsersRepository::new(state);
 		let email = match extract_email_token(payload.token.clone()) {
-			Some(email) => email,
+			Some(token) => token,
 			None => {
 				return common_response(StatusCode::BAD_REQUEST, "Invalid or missing token");
 			}
 		};
 		let password = match hash_password(&payload.password) {
 			Ok(p) => p,
-			Err(_) => {
+			Err(_e) => {
+				error!("Failed to hash new password for {}: {}", email, _e);
 				return common_response(
 					StatusCode::INTERNAL_SERVER_ERROR,
 					"Failed to hash password",
@@ -343,7 +504,9 @@ impl AuthService {
 		};
 		let user = match repo.query_user_by_email(email.clone()).await {
 			Ok(user) if !user.is_deleted => user,
-			_ => return common_response(StatusCode::NOT_FOUND, "User not found"),
+			_ => {
+				return common_response(StatusCode::NOT_FOUND, "User not found");
+			}
 		};
 		let patch = UsersSchema {
 			id: user.id.clone(),
@@ -352,7 +515,7 @@ impl AuthService {
 		};
 		match repo.query_update_user(patch).await {
 			Ok(msg) => common_response(StatusCode::OK, &msg),
-			Err(e) => common_response(StatusCode::BAD_REQUEST, &e.to_string()),
+			Err(_e) => common_response(StatusCode::BAD_REQUEST, &_e.to_string()),
 		}
 	}
 }

imphnen-iam/src/v1/auth/mod.rs

@@ -15,6 +15,7 @@ pub fn auth_router() -> Router {
 	Router::new()
 		.route("/forgot", post(auth_controller::post_forgot_password))
 		.route("/login", post(auth_controller::post_login))
+		.route("/login-mentor", post(auth_controller::post_login_mentor))
 		.route("/new-password", post(auth_controller::post_new_password))
 		.route("/refresh", post(auth_controller::post_refresh_token))
 		.route("/register", post(auth_controller::post_register))

imphnen-iam/src/v1/permissions/permissions_enum.rs

@@ -1,6 +1,8 @@
 use std::fmt;
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+use strum_macros::EnumIter;
+
+#[derive(Debug, Clone, PartialEq, Eq, EnumIter)]
 pub enum PermissionsEnum {
 	ReadListUsers,
 	ReadDetailUsers,
@@ -28,6 +30,16 @@ pub enum PermissionsEnum {
 	ReadDetailGachaRolls,
 	CreateGachaRolls,
 	ExecuteGachaRolls,
+	DeleteGachaRolls,
+	ReadListMentors,
+	ReadDetailMentors,
+	RegisterMentors,
+	ReadOwnMentorProfile,
+	UpdateOwnMentorProfile,
+	ReadOwnMentorStatus,
+	UpdateMentors,
+	VerifyMentors,
+	DeleteMentors,
 }
 
 impl fmt::Display for PermissionsEnum {
@@ -59,8 +71,18 @@ impl fmt::Display for PermissionsEnum {
 			PermissionsEnum::ReadDetailGachaRolls => "Read Detail Gacha Rolls",
 			PermissionsEnum::CreateGachaRolls => "Create Gacha Rolls",
 			PermissionsEnum::ExecuteGachaRolls => "Execute Gacha Rolls",
+			PermissionsEnum::DeleteGachaRolls => "Delete Gacha Rolls",
+			PermissionsEnum::ReadListMentors => "Read List Mentors",
+			PermissionsEnum::ReadDetailMentors => "Read Detail Mentors",
+			PermissionsEnum::RegisterMentors => "Register Mentors",
+			PermissionsEnum::ReadOwnMentorProfile => "Read Own Mentor Profile",
+			PermissionsEnum::UpdateOwnMentorProfile => "Update Own Mentor Profile",
+			PermissionsEnum::ReadOwnMentorStatus => "Read Own Mentor Status",
+			PermissionsEnum::UpdateMentors => "Update Mentors",
+			PermissionsEnum::VerifyMentors => "Verify Mentors",
+			PermissionsEnum::DeleteMentors => "Delete Mentors",
 		};
-		write!(f, "{}", permission_str)
+		write!(f, "{permission_str}")
 	}
 }
 
@@ -101,6 +123,20 @@ impl PermissionsEnum {
 			}
 			PermissionsEnum::CreateGachaRolls => "18e36c63-fcb7-4877-b911-c5aa611e878f",
 			PermissionsEnum::ExecuteGachaRolls => "14c6a1cd-5c63-4643-89b5-b1a5f9920cc0",
+			PermissionsEnum::DeleteGachaRolls => "12345678-ABCD-EFAB-CDEF-0123456789AB",
+			PermissionsEnum::ReadListMentors => "a1b2c3d4-5e6f-7890-abcd-ef1234567890",
+			PermissionsEnum::ReadDetailMentors => "b2c3d4e5-6f78-9012-bcde-f23456789012",
+			PermissionsEnum::RegisterMentors => "c3d4e5f6-7890-1234-cdef-345678901234",
+			PermissionsEnum::ReadOwnMentorProfile => {
+				"d4e5f6a7-8901-2345-def0-456789012345"
+			}
+			PermissionsEnum::UpdateOwnMentorProfile => {
+				"e5f6a7b8-9012-3456-ef01-567890123456"
+			}
+			PermissionsEnum::ReadOwnMentorStatus => "f6a7b8c9-0123-4567-f012-678901234567",
+			PermissionsEnum::UpdateMentors => "a7b8c9d0-1234-5678-0123-789012345678",
+			PermissionsEnum::VerifyMentors => "b8c9d0e1-2345-6789-1234-890123456789",
+			PermissionsEnum::DeleteMentors => "c9d0e1f2-3456-7890-2345-901234567890",
 		}
 	}
 }

imphnen-iam/src/v1/permissions/permissions_guard.rs

@@ -1,5 +1,5 @@
 use super::PermissionsEnum;
-use crate::{common_response, extract_email, AppState, AuthRepository};
+use crate::{AppState, AuthRepository, common_response, extract_email};
 use axum::{
 	http::{HeaderMap, StatusCode},
 	response::Response,
@@ -29,14 +29,16 @@ pub async fn permissions_guard(
 	let role = raw_user.role;
 	let role_permissions: Vec<String> =
 		role.permissions.into_iter().map(|perm| perm.name).collect();
-	let has_all_permissions = required_permissions
-		.iter()
-		.all(|required| role_permissions.contains(&required.to_string()));
-	if !has_all_permissions {
-		return Err(common_response(
-			StatusCode::FORBIDDEN,
-			"You don't have the required permissions",
-		));
+
+	for required in &required_permissions {
+		let required_str = required.to_string();
+		if !role_permissions.contains(&required_str) {
+			eprintln!("  MISSING REQUIRED PERMISSION: {required_str}");
+			return Err(common_response(
+				StatusCode::FORBIDDEN,
+				"You don't have the required permissions",
+			));
+		}
 	}
 	Ok(())
 }

imphnen-iam/src/v1/permissions/permissions_repository.rs

@@ -4,6 +4,9 @@ use crate::{
 };
 use anyhow::{Result, bail};
 use imphnen_utils::{DetailQueryBuilder, QueryListBuilder, extract_id};
+use serde_json;
+use std::time::Instant;
+use tracing::instrument;
 
 pub struct PermissionsRepository<'a> {
 	state: &'a AppState,
@@ -14,10 +17,12 @@ impl<'a> PermissionsRepository<'a> {
 		Self { state }
 	}
 
+	#[instrument(skip(self, meta), err)]
 	pub async fn query_permission_list(
 		&self,
 		meta: MetaRequestDto,
 	) -> Result<ResponseListSuccessDto<Vec<PermissionsItemDto>>> {
+		let now = Instant::now();
 		let raw_result: ResponseListSuccessDto<Vec<PermissionsSchema>> =
 			QueryListBuilder::new(
 				&self.state.surrealdb_ws,
@@ -30,6 +35,13 @@ impl<'a> PermissionsRepository<'a> {
 			.build()
 			.await?;
 
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_permission_list' took: {elapsed:.2?}");
+		}
+
 		let transformed_data = raw_result
 			.data
 			.into_iter()
@@ -42,25 +54,41 @@ impl<'a> PermissionsRepository<'a> {
 		})
 	}
 
+	#[instrument(skip(self, id), err)]
 	pub async fn query_permission_by_id(
 		&self,
 		id: String,
 	) -> Result<PermissionsSchema> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
 		let result: Option<PermissionsSchema> = db
 			.select((ResourceEnum::Permissions.to_string(), id.clone()))
 			.await?;
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_permission_by_id' took: {elapsed:.2?}");
+		}
 		match result {
 			Some(permission) if !permission.is_deleted => Ok(permission),
 			_ => bail!("Permission not found"),
 		}
 	}
 
+	#[instrument(skip(self, id), err)]
 	pub async fn transformed_query_permission_by_id(
 		&self,
 		id: String,
 	) -> Result<PermissionsItemDto> {
+		let now = Instant::now();
 		let raw_result = self.query_permission_by_id(id.clone()).await?;
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'transformed_query_permission_by_id' took: {elapsed:.2?}");
+		}
 		let transformed_data = PermissionsItemDto {
 			id: extract_id(&raw_result.id),
 			name: raw_result.name,
@@ -70,43 +98,60 @@ impl<'a> PermissionsRepository<'a> {
 		Ok(transformed_data)
 	}
 
+	#[instrument(skip(self, name), err)]
 	pub async fn query_permission_by_name(
 		&self,
 		name: String,
 	) -> Result<PermissionsSchema> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
 		let builder = DetailQueryBuilder::new(ResourceEnum::Permissions.to_string())
-			.with_where("name")
-			.where_value(name.clone())
+			.with_where("name", Some(name.clone()))
 			.with_select_fields(vec!["*"]);
 		let sql = builder.build();
 		let result: Option<PermissionsSchema> =
 			builder.apply_bindings(db.query(sql)).await?.take(0)?;
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_permission_by_name' took: {elapsed:.2?}");
+		}
 		match result {
 			Some(permission) => Ok(permission),
 			None => bail!("Permission not found"),
 		}
 	}
 
+	#[instrument(skip(self, data), err)]
 	pub async fn query_create_permission(
 		&self,
 		data: PermissionsSchema,
 	) -> Result<String> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
 		let record: Option<PermissionsSchema> = db
 			.create(ResourceEnum::Permissions.to_string())
 			.content(data)
 			.await?;
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_create_permission' took: {elapsed:.2?}");
+		}
 		match record {
 			Some(_) => Ok("Success create permission".into()),
 			None => bail!("Failed to create permission"),
 		}
 	}
 
+	#[instrument(skip(self, data), err)]
 	pub async fn query_update_permission(
 		&self,
 		data: PermissionsSchema,
 	) -> Result<String> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
 		let record_key = get_id(&data.id)?;
 		let existing = self.query_permission_by_id(data.id.id.to_raw()).await?;
@@ -119,13 +164,21 @@ impl<'a> PermissionsRepository<'a> {
 		};
 		let record: Option<PermissionsSchema> =
 			db.update(record_key).merge(merged).await?;
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_update_permission' took: {elapsed:.2?}");
+		}
 		match record {
 			Some(_) => Ok("Success update permission".into()),
 			None => bail!("Failed to update permission"),
 		}
 	}
 
+	#[instrument(skip(self, id), err)]
 	pub async fn query_delete_permission(&self, id: String) -> Result<String> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
 		let permission_id = make_thing(&ResourceEnum::Permissions.to_string(), &id);
 		let permission = self
@@ -139,6 +192,12 @@ impl<'a> PermissionsRepository<'a> {
 			.update(record_key)
 			.merge(serde_json::json!({ "is_deleted": true }))
 			.await?;
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_delete_permission' took: {elapsed:.2?}");
+		}
 		match record {
 			Some(_) => Ok("Success delete permission".into()),
 			None => bail!("Failed to delete permission"),

imphnen-iam/src/v1/permissions/permissions_service.rs

@@ -1,7 +1,7 @@
 use crate::{
-	common_response, make_thing, success_list_response, success_response,
-	validate_request, AppState, MetaRequestDto, PermissionsRepository,
-	PermissionsSchema, ResourceEnum, ResponseListSuccessDto, ResponseSuccessDto,
+	AppState, MetaRequestDto, PermissionsRepository, PermissionsSchema, ResourceEnum,
+	ResponseListSuccessDto, ResponseSuccessDto, common_response, make_thing,
+	success_list_response, success_response, validate_request,
 };
 use axum::http::StatusCode;
 use axum::response::Response;

imphnen-iam/src/v1/roles/roles_dto.rs

@@ -64,3 +64,16 @@ pub struct RolesDetailQueryDto {
 	pub created_at: Option<String>,
 	pub updated_at: Option<String>,
 }
+
+impl Default for RolesDetailQueryDto {
+	fn default() -> Self {
+		Self {
+			id: Thing::from(("".to_string(), surrealdb::sql::Id::Number(0))),
+			name: String::new(),
+			permissions: Vec::new(),
+			is_deleted: false,
+			created_at: None,
+			updated_at: None,
+		}
+	}
+}

imphnen-iam/src/v1/roles/roles_enum.rs

@@ -5,6 +5,7 @@ pub enum RolesEnum {
 	Admin,
 	User,
 	Staff,
+	Mentor, // Added Mentor role
 }
 
 impl fmt::Display for RolesEnum {
@@ -13,7 +14,8 @@ impl fmt::Display for RolesEnum {
 			RolesEnum::Admin => "Admin",
 			RolesEnum::User => "User",
 			RolesEnum::Staff => "Staff",
+			RolesEnum::Mentor => "Mentor", // Added Mentor role
 		};
-		write!(f, "{}", roles_str)
+		write!(f, "{roles_str}")
 	}
 }

imphnen-iam/src/v1/roles/roles_repository.rs

@@ -7,8 +7,11 @@ use crate::{
 };
 use anyhow::{Result, bail};
 use imphnen_utils::{DetailQueryBuilder, QueryListBuilder};
+use serde_json;
+use std::time::Instant;
 use surrealdb::Uuid;
 use surrealdb::sql::Thing;
+use tracing::instrument;
 
 pub struct RolesRepository<'a> {
 	state: &'a AppState,
@@ -19,10 +22,12 @@ impl<'a> RolesRepository<'a> {
 		Self { state }
 	}
 
+	#[instrument(skip(self, meta), err)]
 	pub async fn query_role_list(
 		&self,
 		meta: MetaRequestDto,
 	) -> Result<ResponseListSuccessDto<Vec<RolesListItemDto>>> {
+		let now = Instant::now();
 		let result: ResponseListSuccessDto<Vec<RolesSchema>> = QueryListBuilder::new(
 			&self.state.surrealdb_ws,
 			&ResourceEnum::Roles.to_string(),
@@ -31,6 +36,12 @@ impl<'a> RolesRepository<'a> {
 		.search_field("name")
 		.build()
 		.await?;
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_role_list' took: {elapsed:.2?}");
+		}
 		let data = result
 			.data
 			.into_iter()
@@ -42,48 +53,71 @@ impl<'a> RolesRepository<'a> {
 		})
 	}
 
+	#[instrument(skip(self, name), err)]
 	pub async fn query_role_by_name(
 		&self,
 		name: String,
 	) -> Result<RolesDetailItemDto> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
 		let builder = DetailQueryBuilder::new(ResourceEnum::Roles.to_string())
-			.with_where("name")
-			.where_value(name.clone())
+			.with_where("name", Some(name.clone()))
 			.with_select_fields(vec!["*"])
 			.with_fetch("permissions");
 		let sql = builder.build();
-		let result: Option<RolesDetailQueryDto> = builder
-			.apply_bindings(db.query(sql).bind(("name", name)))
-			.await?
-			.take(0)?;
-		let role = match result {
-			Some(r) if !r.is_deleted => r,
-			_ => bail!("Role not found"),
-		};
+		let mut response = builder.apply_bindings(db.query(sql)).await?;
+
+		let result_vec: Vec<RolesDetailQueryDto> = response.take(0).map_err(|e| {
+			anyhow::anyhow!("Failed to take result from response: {:?}", e)
+		})?;
+
+		let role = result_vec
+			.into_iter()
+			.next()
+			.ok_or_else(|| anyhow::anyhow!("Role not found"))?;
+
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_role_by_name' took: {elapsed:.2?}");
+		}
 		Ok(RolesDetailItemDto::from(&role))
 	}
 
+	#[instrument(skip(self, id), err)]
 	pub async fn query_role_by_id(&self, id: String) -> Result<RolesDetailItemDto> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
+		let thing_id = make_thing(&ResourceEnum::Roles.to_string(), &id);
 		let builder = DetailQueryBuilder::new(ResourceEnum::Roles.to_string())
 			.with_id(&id)
 			.with_select_fields(vec!["*"])
 			.with_fetch("permissions");
+
 		let sql = builder.build();
+		let sql_debug = sql.to_string(); // Move this line here
 		let result: Option<RolesDetailQueryDto> =
 			builder.apply_bindings(db.query(sql)).await?.take(0)?;
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_role_by_id' took: {elapsed:.2?}");
+		}
 		let role = match result {
 			Some(r) if !r.is_deleted => r,
-			_ => bail!("Role not found"),
+			_ => bail!("Role not found sql: {} id: {}", sql_debug, thing_id),
 		};
 		Ok(RolesDetailItemDto::from(&role))
 	}
 
+	#[instrument(skip(self, payload), err)]
 	pub async fn query_create_role(
 		&self,
 		payload: RolesRequestCreateDto,
 	) -> Result<String> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
 		let role_id = Uuid::new_v4().to_string();
 		let permission_things: Vec<Thing> = payload
@@ -103,14 +137,22 @@ impl<'a> RolesRepository<'a> {
 			.create((&ResourceEnum::Roles.to_string(), role_id))
 			.content(role)
 			.await?;
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_create_role' took: {elapsed:.2?}");
+		}
 		Ok("Role with permissions created successfully".into())
 	}
 
+	#[instrument(skip(self, id, data), err)]
 	pub async fn query_update_role(
 		&self,
 		id: String,
 		data: RolesRequestUpdateDto,
 	) -> Result<String> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
 		let existing = self.query_role_by_id(id.clone()).await?;
 		if existing.is_deleted {
@@ -119,13 +161,21 @@ impl<'a> RolesRepository<'a> {
 		let merged = RolesSchema::update(data, id.clone(), existing);
 		let record: Option<RolesSchema> =
 			db.update(get_id(&merged.id)?).content(merged).await?;
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_update_role' took: {elapsed:.2?}");
+		}
 		match record {
 			Some(_) => Ok("Success update role".into()),
 			None => bail!("Failed to update role"),
 		}
 	}
 
+	#[instrument(skip(self, id), err)]
 	pub async fn query_delete_role(&self, id: String) -> Result<String> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
 		let role_id = make_thing(&ResourceEnum::Roles.to_string(), &id);
 		let role = self.query_role_by_id(role_id.id.to_raw()).await?;
@@ -137,6 +187,12 @@ impl<'a> RolesRepository<'a> {
 			.update(record_key)
 			.merge(serde_json::json!({ "is_deleted": true }))
 			.await?;
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_delete_role' took: {elapsed:.2?}");
+		}
 		match record {
 			Some(_) => Ok("Success delete role".into()),
 			None => bail!("Failed to delete role"),

imphnen-iam/src/v1/users/users_dto.rs

@@ -1,13 +1,13 @@
 use crate::{RolesDetailItemDto, RolesDetailQueryDto};
 use lazy_static::lazy_static;
-use regex::Regex;
 use serde::{Deserialize, Serialize};
 use surrealdb::sql::Thing;
 use utoipa::ToSchema;
 use validator::Validate;
 
 lazy_static! {
-	static ref PASSWORD_REGEX: Regex = Regex::new(r"^[A-Za-z\d@$!%*?&]{8,}$").unwrap();
+	static ref PASSWORD_REGEX: regex::Regex =
+		regex::Regex::new(r"^[A-Za-z\d@$!%*?&]{8,}$").unwrap();
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
@@ -34,7 +34,7 @@ pub struct UsersCreateRequestDto {
 		message = "Password must have at least 8 characters"
 	))]
 	#[validate(regex(
-		path = "PASSWORD_REGEX",
+		path = "*PASSWORD_REGEX",
 		message = "Password must include uppercase, lowercase, number, and special character"
 	))]
 	pub password: String,
@@ -62,6 +62,7 @@ pub struct UsersUpdateRequestDto {
 		min = 8,
 		message = "Password must have at least 8 characters"
 	))]
+	pub password: String,
 	#[validate(length(min = 2, message = "Fullname at least have 2 character"))]
 	pub fullname: String,
 	#[validate(length(
@@ -103,7 +104,7 @@ impl UsersDetailItemDto {
 			email: dto.email.clone(),
 			avatar: dto.avatar.clone(),
 			phone_number: dto.phone_number.clone(),
-			is_active: dto.is_active.clone(),
+			is_active: dto.is_active,
 			gender: dto.gender.clone(),
 			birthdate: dto.birthdate.clone(),
 			created_at: dto.created_at.clone(),
@@ -169,18 +170,20 @@ pub struct UsersDetailQueryDto {
 	pub role: RolesDetailQueryDto,
 	pub created_at: String,
 	pub updated_at: String,
+	pub mentor_id: Option<Thing>,
 }
 
 impl UsersDetailQueryDto {
 	pub fn from(&self) -> Self {
 		Self {
 			id: self.id.clone(),
-			role: RolesDetailQueryDto::from(self.role.clone()),
+			role: self.role.clone(),
 			fullname: self.fullname.clone(),
 			email: self.email.clone(),
 			avatar: self.avatar.clone(),
 			phone_number: self.phone_number.clone(),
 			is_active: self.is_active,
+			mentor_id: self.mentor_id.clone(),
 			gender: self.gender.clone(),
 			is_deleted: self.is_deleted,
 			password: self.password.clone(),
@@ -190,3 +193,24 @@ impl UsersDetailQueryDto {
 		}
 	}
 }
+
+impl From<&UsersDetailItemDto> for UsersDetailQueryDto {
+	fn from(dto: &UsersDetailItemDto) -> Self {
+		Self {
+			id: crate::make_thing(&imphnen_libs::ResourceEnum::Users.to_string(), &dto.id),
+			fullname: dto.fullname.clone(),
+			email: dto.email.clone(),
+			avatar: dto.avatar.clone(),
+			phone_number: dto.phone_number.clone(),
+			is_active: dto.is_active,
+			is_deleted: false,
+			gender: dto.gender.clone(),
+			birthdate: dto.birthdate.clone(),
+			password: String::new(),
+			role: RolesDetailQueryDto::default(),
+			created_at: dto.created_at.clone(),
+			updated_at: dto.updated_at.clone(),
+			mentor_id: None,
+		}
+	}
+}

imphnen-iam/src/v1/users/users_repository.rs

@@ -2,10 +2,16 @@ use super::{UsersDetailQueryDto, UsersListItemDto, UsersListQueryDto, UsersSchem
 use crate::{
 	AppState, MetaRequestDto, ResourceEnum, ResponseListSuccessDto, get_id, make_thing,
 };
+use surrealdb::sql::Thing;
 use anyhow::{Result, bail};
 use imphnen_utils::{DetailQueryBuilder, QueryListBuilder};
+use serde_json;
+use std::time::Instant;
 use surrealdb::{Surreal, engine::remote::ws::Client};
 
+
+
+
 pub struct UsersRepository<'a> {
 	state: &'a AppState,
 }
@@ -30,10 +36,12 @@ impl<'a> UsersRepository<'a> {
 		Self { state }
 	}
 
+	
 	pub async fn query_user_list(
 		&self,
 		meta: MetaRequestDto,
 	) -> Result<ResponseListSuccessDto<Vec<UsersListItemDto>>> {
+		let now = Instant::now();
 		let result: ResponseListSuccessDto<Vec<UsersListQueryDto>> =
 			QueryListBuilder::new(
 				&self.state.surrealdb_ws,
@@ -46,6 +54,14 @@ impl<'a> UsersRepository<'a> {
 			.fetch_fields(vec!["role", "role.permissions"])
 			.build()
 			.await?;
+		let elapsed = now.elapsed();
+
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_user_list' took: {elapsed:.2?}");
+		}
+
 		let data = result
 			.data
 			.into_iter()
@@ -57,70 +73,103 @@ impl<'a> UsersRepository<'a> {
 		})
 	}
 
+	
 	pub async fn query_user_by_email(
 		&self,
 		email: String,
 	) -> Result<UsersDetailQueryDto> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
 		let builder = DetailQueryBuilder::new(ResourceEnum::Users.to_string())
-			.with_where("email")
-			.where_value(email.clone())
+			.with_where("email", Some(email.clone()))
 			.with_select_fields(vec!["*"])
 			.with_fetch("role")
 			.with_fetch("role.permissions");
 		let sql = builder.build();
 		let user_opt: Option<UsersDetailQueryDto> =
 			builder.apply_bindings(db.query(sql)).await?.take(0)?;
+		let elapsed = now.elapsed();
+
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_user_by_email' took: {elapsed:.2?}");
+		}
+
 		let Some(user) = user_opt else {
 			bail!("User not found");
 		};
 		if user.is_deleted {
 			bail!("User not found");
 		}
-		if user.role.is_deleted {
+		if user.role.updated_at.is_none() || user.role.is_deleted {
 			bail!("User not found");
 		}
 		Ok(UsersDetailQueryDto::from(&user))
 	}
 
-	pub async fn query_user_by_id(&self, id: String) -> Result<UsersDetailQueryDto> {
+	
+
+
+	pub async fn query_user_by_id(&self, id: &Thing) -> Result<UsersDetailQueryDto> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
 		let builder = DetailQueryBuilder::new(ResourceEnum::Users.to_string())
-			.with_id(&id)
+			.with_id(&id.id.to_raw())
 			.with_select_fields(vec!["*"])
 			.with_fetch("role")
 			.with_fetch("role.permissions");
 		let sql = builder.build();
 		let result: Option<UsersDetailQueryDto> =
 			builder.apply_bindings(db.query(sql)).await?.take(0)?;
+		let elapsed = now.elapsed();
+
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_user_by_id' took: {elapsed:.2?}");
+		}
+
 		let Some(user) = result else {
-			bail!("User not found");
+			bail!("User not found in database");
 		};
 		if user.is_deleted {
 			bail!("User not found");
 		}
 		if user.role.is_deleted {
-			bail!("User not found");
+			bail!("User's role has been deleted");
 		}
 		Ok(UsersDetailQueryDto::from(&user))
 	}
 
+	
 	pub async fn query_create_user(&self, data: UsersSchema) -> Result<String> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
 		let record: Option<UsersSchema> = db
 			.create(ResourceEnum::Users.to_string())
 			.content(data)
 			.await?;
+		let elapsed = now.elapsed();
+
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_create_user' took: {elapsed:.2?}");
+		}
+
 		match record {
 			Some(_) => Ok("Success create user".into()),
 			None => bail!("Failed to create user"),
 		}
 	}
 
+	
 	pub async fn query_update_user(&self, data: UsersSchema) -> Result<String> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
 		let record_key = get_id(&data.id)?;
-		let existing = self.query_user_by_id(data.id.id.to_raw()).await?;
+		let existing = self.query_user_by_id(&data.id).await?;
 		if existing.is_deleted {
 			bail!("User already deleted");
 		}
@@ -136,15 +185,25 @@ impl<'a> UsersRepository<'a> {
 			..data.clone()
 		};
 		let record: Option<UsersSchema> = db.update(record_key).merge(merged).await?;
+		let elapsed = now.elapsed();
+
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_update_user' took: {elapsed:.2?}");
+		}
+
 		match record {
 			Some(_) => Ok("Success update user".into()),
 			None => bail!("Failed to update user"),
 		}
 	}
 
+	
 	pub async fn query_delete_user(&self, id: String) -> Result<String> {
+		let now = Instant::now();
 		let db = &self.state.surrealdb_ws;
-		let user = self.query_user_by_id(id).await?;
+		let user = self.query_user_by_id(&make_thing(&ResourceEnum::Users.to_string(), &id)).await?;
 		if user.is_deleted {
 			bail!("User not found");
 		}
@@ -153,9 +212,18 @@ impl<'a> UsersRepository<'a> {
 			.update(record_key)
 			.merge(serde_json::json!({ "is_deleted": true }))
 			.await?;
+		let elapsed = now.elapsed();
+
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_delete_user' took: {elapsed:.2?}");
+		}
+
 		match record {
 			Some(_) => Ok("Success delete user".into()),
 			None => bail!("Failed to delete user"),
 		}
 	}
 }
+

imphnen-iam/src/v1/users/users_schema.rs

@@ -1,5 +1,6 @@
 use super::{UsersCreateRequestDto, UsersDetailQueryDto, UsersUpdateRequestDto};
 use imphnen_libs::{ResourceEnum, hash_password};
+use imphnen_utils::extract_id;
 use imphnen_utils::{get_iso_date, make_thing};
 use serde::{Deserialize, Serialize};
 use surrealdb::{Uuid, sql::Thing};
@@ -10,11 +11,16 @@ pub struct UsersSchema {
 	pub fullname: String,
 	pub email: String,
 	pub password: String,
+	#[serde(skip_serializing_if = "Option::is_none")]
 	pub avatar: Option<String>,
 	pub phone_number: String,
 	pub is_active: bool,
 	pub is_deleted: bool,
+	#[serde(skip_serializing_if = "Option::is_none")]
+	pub mentor_id: Option<Thing>,
+	#[serde(skip_serializing_if = "Option::is_none")]
 	pub gender: Option<String>,
+	#[serde(skip_serializing_if = "Option::is_none")]
 	pub birthdate: Option<String>,
 	pub role: Thing,
 	pub created_at: String,
@@ -35,6 +41,10 @@ impl Default for UsersSchema {
 			phone_number: String::new(),
 			is_active: false,
 			is_deleted: false,
+			mentor_id: Some(make_thing(
+				&ResourceEnum::Users.to_string(),
+				&Uuid::new_v4().to_string(),
+			)),
 			gender: None,
 			birthdate: None,
 			role: make_thing(
@@ -57,12 +67,18 @@ impl UsersSchema {
 			phone_number: dto.phone_number,
 			is_active: dto.is_active,
 			is_deleted: dto.is_deleted,
+			mentor_id: Some(dto.mentor_id.unwrap_or_else(|| {
+				make_thing(
+					&ResourceEnum::Users.to_string(),
+					&Uuid::new_v4().to_string(),
+				)
+			})),
 			gender: dto.gender,
 			birthdate: dto.birthdate,
 			password: dto.password,
 			created_at: dto.created_at,
 			updated_at: dto.updated_at,
-			role: make_thing(&ResourceEnum::Roles.to_string(), &dto.role.id.id.to_raw()),
+			role: make_thing(&ResourceEnum::Roles.to_string(), &extract_id(&dto.role.id)),
 		}
 	}
 
@@ -95,6 +111,10 @@ impl UsersSchema {
 			password,
 			phone_number: user.phone_number,
 			is_active: false,
+			mentor_id: Some(make_thing(
+				&ResourceEnum::Users.to_string(),
+				&Uuid::new_v4().to_string(),
+			)),
 			gender: None,
 			birthdate: None,
 			avatar: None,
@@ -112,4 +132,16 @@ impl UsersSchema {
 			..Self::from(dto)
 		}
 	}
+
+	pub fn update_mentor_id(mut self, mentor_id: Option<String>) -> Self {
+		self.mentor_id = match mentor_id {
+			Some(id) => Some(make_thing(&ResourceEnum::Users.to_string(), &id)),
+			None => Some(make_thing(
+				&ResourceEnum::Users.to_string(),
+				&Uuid::new_v4().to_string(),
+			)),
+		};
+		self.updated_at = get_iso_date();
+		self
+	}
 }

imphnen-iam/src/v1/users/users_service.rs

@@ -6,12 +6,15 @@ use crate::{
 	AppState, MetaRequestDto, ResponseListSuccessDto, UsersRepository, UsersSchema,
 };
 use crate::{
-	ResourceEnum, ResponseSuccessDto, common_response, extract_email, make_thing,
-	success_list_response, success_response, validate_request,
+	ResponseSuccessDto, common_response, extract_email, success_list_response,
+	success_response, validate_request,
 };
 use axum::http::HeaderMap;
 use axum::{http::StatusCode, response::Response};
-use imphnen_libs::{hash_password, verify_password};
+use imphnen_libs::{ResourceEnum, hash_password, verify_password};
+use imphnen_utils::make_thing;
+use uuid::Uuid;
+
 
 pub struct UsersService;
 
@@ -31,8 +34,12 @@ impl UsersService {
 	}
 
 	pub async fn get_user_by_id(state: &AppState, id: String) -> Response {
+		if Uuid::parse_str(&id).is_err() {
+            return common_response(StatusCode::BAD_REQUEST, "Invalid User ID format");
+        }
 		let repo = UsersRepository::new(state);
-		match repo.query_user_by_id(id).await {
+		let thing_id = make_thing(&ResourceEnum::Users.to_string(), &id);
+		match repo.query_user_by_id(&thing_id).await {
 			Ok(user) if !user.is_deleted => success_response(ResponseSuccessDto {
 				data: UsersDetailItemDto::from(&user),
 			}),
@@ -84,6 +91,9 @@ impl UsersService {
 		id: String,
 		user: UsersUpdateRequestDto,
 	) -> Response {
+		if Uuid::parse_str(&id).is_err() {
+            return common_response(StatusCode::BAD_REQUEST, "Invalid User ID format");
+        }
 		let repo = UsersRepository::new(state);
 		if let Err((status, message)) = validate_request(&user) {
 			return common_response(status, &message);
@@ -124,9 +134,12 @@ impl UsersService {
 		id: String,
 		payload: UsersActiveInactiveRequestDto,
 	) -> Response {
+		if Uuid::parse_str(&id).is_err() {
+            return common_response(StatusCode::BAD_REQUEST, "Invalid User ID format");
+        }
 		let repo = UsersRepository::new(state);
 		let thing_id = make_thing(&ResourceEnum::Users.to_string(), &id);
-		match repo.query_user_by_id(thing_id.id.to_raw()).await {
+		match repo.query_user_by_id(&thing_id).await {
 			Ok(user) if !user.is_deleted => {
 				let patch = UsersSchema {
 					id: user.id.clone(),
@@ -186,9 +199,28 @@ impl UsersService {
 		}
 	}
 
-	pub async fn delete_user(state: &AppState, id: String) -> Response {
+	pub async fn get_user_by_mentor_id(
+		state: &AppState,
+		mentor_id: String,
+	) -> Response {
 		let repo = UsersRepository::new(state);
-		if repo.query_user_by_id(id.clone()).await.is_err() {
+		let thing_id = make_thing(&ResourceEnum::Mentors.to_string(), &mentor_id);
+		match repo.query_user_by_id(&thing_id).await {
+			Ok(user) if !user.is_deleted => success_response(ResponseSuccessDto {
+				data: UsersDetailItemDto::from(&user),
+			}),
+			Ok(_) => common_response(StatusCode::NOT_FOUND, "User not found"),
+			Err(e) => common_response(StatusCode::NOT_FOUND, &e.to_string()),
+		}
+	}
+
+	pub async fn delete_user(state: &AppState, id: String) -> Response {
+		if Uuid::parse_str(&id).is_err() {
+            return common_response(StatusCode::BAD_REQUEST, "Invalid User ID format");
+        }
+		let repo = UsersRepository::new(state);
+		let thing_id = make_thing(&ResourceEnum::Users.to_string(), &id);
+		if repo.query_user_by_id(&thing_id).await.is_err() {
 			return common_response(StatusCode::BAD_REQUEST, "User not found");
 		}
 		match repo.query_delete_user(id).await {