feat: initial commit

src/apps/mod.rs

@@ -9,6 +9,8 @@ use utoipa_swagger_ui::SwaggerUi;
 pub mod v1;
 pub mod v2;
 
+pub use v1::*;
+
 pub async fn apps(surrealdb: SurrealClient, redisdb: RedisClient) -> Router {
 	let state = AppState { surrealdb, redisdb };
 	let env = Env::new();

src/apps/v1/auth/auth_dto.rs

@@ -1,8 +1,7 @@
+use crate::UsersItemDto;
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 
-use crate::v1::UsersItemDto;
-
 #[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
 pub struct AuthLoginRequestDto {
 	pub email: String,

src/apps/v1/auth/auth_middleware.rs

@@ -1,6 +1,6 @@
-use super::AuthRepository;
 use crate::{
 	common_response, extract_email, v1::users_schema::UsersSchema, AppState,
+	UsersRepository,
 };
 use axum::{
 	extract::Request, http::StatusCode, middleware::Next, response::Response,
@@ -25,7 +25,7 @@ pub async fn auth_middleware(
 		}
 	};
 
-	let repository = AuthRepository::new(&state);
+	let repository = UsersRepository::new(&state);
 
 	let user: Option<UsersSchema> = match repository.query_user_by_email(email).await {
 		Ok(user) => Some(user),

src/apps/v1/auth/auth_repository.rs

@@ -1,10 +1,4 @@
-use super::{
-	AuthActiveInactiveRequestDto, AuthRegisterRequestDto, AuthSetNewPasswordRequestDto,
-};
-use crate::{
-	v1::{users_schema::UsersSchema, UsersItemDto},
-	AppState, RedisKeyEnum, ResourceEnum,
-};
+use crate::{AppState, RedisKeyEnum, UsersSchema};
 use anyhow::{anyhow, bail, Result};
 use redis::Commands;
 
@@ -17,10 +11,7 @@ impl<'a> AuthRepository<'a> {
 		Self { state }
 	}
 
-	pub fn query_store_user_data(
-		&self,
-		user: AuthRegisterRequestDto,
-	) -> Result<String> {
+	pub fn query_store_user_data(&self, user: UsersSchema) -> Result<String> {
 		let redis_key = format!("{}:{}", RedisKeyEnum::User, user.email.clone());
 		match &self.state.redisdb.get_connection().and_then(|mut conn| {
 			conn.set_ex::<_, String, ()>(
@@ -34,13 +25,13 @@ impl<'a> AuthRepository<'a> {
 		}
 	}
 
-	pub fn query_get_stored_user(&self, email: String) -> Result<UsersItemDto> {
+	pub fn query_get_stored_user(&self, email: String) -> Result<UsersSchema> {
 		let redis_key = format!("{}:{}", RedisKeyEnum::User, email);
 		let mut conn = self.state.redisdb.get_connection()?;
 		let data: Option<String> = conn.get(&redis_key)?;
 		match data {
 			Some(user_json) => {
-				let user: UsersItemDto = serde_json::from_str(&user_json)?;
+				let user: UsersSchema = serde_json::from_str(&user_json)?;
 				Ok(user)
 			}
 			None => bail!("No stored user data found"),
@@ -92,73 +83,4 @@ impl<'a> AuthRepository<'a> {
 			Err(e) => Err(anyhow!("Failed to delete OTP from Redis: {}", e)),
 		}
 	}
-
-	pub async fn query_user_by_email(&self, email: String) -> Result<UsersSchema> {
-		let db = &self.state.surrealdb;
-		let result = db
-			.select((ResourceEnum::Users.to_string(), email.clone()))
-			.await?;
-		match result {
-			Some(response) => Ok(response),
-			None => {
-				bail!("User not found")
-			}
-		}
-	}
-
-	pub async fn query_create_user(
-		&self,
-		data: AuthRegisterRequestDto,
-	) -> Result<String> {
-		let db = &self.state.surrealdb;
-		let record: Option<UsersItemDto> = db
-			.create((ResourceEnum::Users.to_string(), &data.email))
-			.content(UsersSchema {
-				fullname: data.fullname.clone(),
-				email: data.email.clone(),
-				password: data.password.clone(),
-				is_active: false,
-			})
-			.await?;
-		match record {
-			Some(_) => Ok("Success create user".into()),
-			None => bail!("Failed to create user"),
-		}
-	}
-
-	pub async fn query_active_inactive_user(
-		&self,
-		data: AuthActiveInactiveRequestDto,
-	) -> Result<String> {
-		let db = &self.state.surrealdb;
-		let record: Option<AuthActiveInactiveRequestDto> = db
-			.update((ResourceEnum::Users.to_string(), &data.email))
-			.merge(AuthActiveInactiveRequestDto {
-				email: data.email.clone(),
-				is_active: data.is_active.clone(),
-			})
-			.await?;
-		match record {
-			Some(_) => Ok("Success update user".into()),
-			None => bail!("Failed to update user"),
-		}
-	}
-
-	pub async fn query_update_password_user(
-		&self,
-		data: AuthSetNewPasswordRequestDto,
-	) -> Result<String> {
-		let db = &self.state.surrealdb;
-		let record: Option<AuthSetNewPasswordRequestDto> = db
-			.update((ResourceEnum::Users.to_string(), &data.email))
-			.merge(AuthSetNewPasswordRequestDto {
-				email: data.email.clone(),
-				password: data.password.clone(),
-			})
-			.await?;
-		match record {
-			Some(_) => Ok("Success update password user".into()),
-			None => bail!("Failed to update password user"),
-		}
-	}
 }

src/apps/v1/auth/auth_service.rs

@@ -1,15 +1,14 @@
-use axum::{http::StatusCode, response::Response};
-
 use super::{
-	AuthActiveInactiveRequestDto, AuthLoginRequestDto, AuthLoginResponsetDto,
-	AuthRegisterRequestDto, AuthRepository, AuthResendOtpRequestDto,
-	AuthVerifyEmailRequestDto, TokenDto,
+	AuthLoginRequestDto, AuthLoginResponsetDto, AuthRegisterRequestDto,
+	AuthRepository, AuthResendOtpRequestDto, AuthVerifyEmailRequestDto, TokenDto,
 };
 use crate::{
 	common_response, encode_access_token, encode_refresh_token, generate_otp,
-	hash_password, send_email, success_response, v1::UsersItemDto, verify_password,
-	AppState, Env, ResponseSuccessDto,
+	hash_password, send_email, success_response, verify_password, AppState, Env,
+	ResponseSuccessDto, UsersActiveInactiveSchema, UsersItemDto, UsersRepository,
+	UsersSchema,
 };
+use axum::{http::StatusCode, response::Response};
 
 pub struct AuthService;
 
@@ -18,9 +17,10 @@ impl AuthService {
 		payload: AuthLoginRequestDto,
 		state: &AppState,
 	) -> Response {
-		let repository = AuthRepository::new(state);
+		let user_repo = UsersRepository::new(state);
+		let auth_repo = AuthRepository::new(state);
 
-		match repository.query_user_by_email(payload.email.clone()).await {
+		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);
@@ -73,11 +73,7 @@ impl AuthService {
 					},
 				};
 
-				if let Err(_) = repository.query_store_user_data(AuthRegisterRequestDto {
-					fullname: user.fullname,
-					password: user.password,
-					email: user.email,
-				}) {
+				if let Err(_) = auth_repo.query_store_user_data(user) {
 					return common_response(StatusCode::BAD_REQUEST, "Failed to store data");
 				}
 
@@ -91,8 +87,10 @@ impl AuthService {
 		payload: AuthRegisterRequestDto,
 		state: &AppState,
 	) -> Response {
-		let repository = AuthRepository::new(state);
-		if repository
+		let user_repo = UsersRepository::new(state);
+		let auth_repo = AuthRepository::new(state);
+
+		if user_repo
 			.query_user_by_email(payload.email.clone())
 			.await
 			.is_ok()
@@ -118,7 +116,7 @@ impl AuthService {
 
 		let otp = generate_otp::OtpManager::generate_otp();
 
-		repository
+		auth_repo
 			.query_store_otp(new_user.email.clone(), otp.clone())
 			.unwrap();
 
@@ -126,7 +124,15 @@ impl AuthService {
 
 		send_email(&new_user.email.clone(), "OTP Verification", &message).unwrap();
 
-		match repository.query_create_user(new_user).await {
+		match user_repo
+			.query_create_user(UsersSchema {
+				email: new_user.email.clone(),
+				fullname: new_user.fullname.clone(),
+				password: new_user.password.clone(),
+				is_active: false,
+			})
+			.await
+		{
 			Ok(_) => common_response(StatusCode::CREATED, "Registration successful"),
 			Err(err) => {
 				common_response(StatusCode::INTERNAL_SERVER_ERROR, &err.to_string())
@@ -154,8 +160,8 @@ impl AuthService {
 		payload: AuthResendOtpRequestDto,
 		state: &AppState,
 	) -> Response {
-		let repository = AuthRepository::new(state);
-		if repository
+		let user_repo = UsersRepository::new(state);
+		if user_repo
 			.query_user_by_email(payload.email.clone())
 			.await
 			.is_err()
@@ -188,14 +194,16 @@ impl AuthService {
 		payload: AuthVerifyEmailRequestDto,
 		state: &AppState,
 	) -> Response {
-		let repository = AuthRepository::new(state);
-		match repository.query_get_stored_otp(payload.email.clone()) {
+		let user_repo = UsersRepository::new(state);
+		let auth_repo = AuthRepository::new(state);
+
+		match auth_repo.query_get_stored_otp(payload.email.clone()) {
 			Ok(stored_otp) => {
 				let user_otp = payload.otp;
 				let is_otp_valid = stored_otp == user_otp;
 				if is_otp_valid {
-					match repository
-						.query_active_inactive_user(AuthActiveInactiveRequestDto {
+					match user_repo
+						.query_active_inactive_user(UsersActiveInactiveSchema {
 							email: payload.email.clone(),
 							is_active: true,
 						})
@@ -203,7 +211,7 @@ impl AuthService {
 					{
 						Ok(_) => {
 							if let Err(e) =
-								repository.query_delete_stored_otp(payload.email.clone())
+								auth_repo.query_delete_stored_otp(payload.email.clone())
 							{
 								return common_response(
 									StatusCode::INTERNAL_SERVER_ERROR,
@@ -215,7 +223,7 @@ impl AuthService {
 						Err(err) => common_response(StatusCode::BAD_REQUEST, &err.to_string()),
 					}
 				} else {
-					if let Err(e) = repository.query_delete_stored_otp(payload.email.clone()) {
+					if let Err(e) = auth_repo.query_delete_stored_otp(payload.email.clone()) {
 						return common_response(
 							StatusCode::INTERNAL_SERVER_ERROR,
 							&format!("Failed to delete OTP: {}", e),

src/apps/v1/users/mod.rs

@@ -1,4 +1,7 @@
 pub mod users_dto;
+pub mod users_repository;
 pub mod users_schema;
 
 pub use users_dto::*;
+pub use users_repository::*;
+pub use users_schema::*;

src/apps/v1/users/users_dto.rs

@@ -1,6 +1,13 @@
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct UsersCreateRequestDto {
+	pub email: String,
+	pub fullname: String,
+	pub password: String,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
 pub struct UsersItemDto {
 	pub email: String,

src/apps/v1/users/users_repository.rs

@@ -0,0 +1,79 @@
+use super::{UsersActiveInactiveSchema, UsersSetNewPasswordSchema};
+use crate::{v1::users_schema::UsersSchema, AppState, ResourceEnum};
+use anyhow::{bail, Result};
+
+pub struct UsersRepository<'a> {
+	state: &'a AppState,
+}
+
+impl<'a> UsersRepository<'a> {
+	pub fn new(state: &'a AppState) -> Self {
+		Self { state }
+	}
+
+	pub async fn query_user_by_email(&self, email: String) -> Result<UsersSchema> {
+		let db = &self.state.surrealdb;
+		let result = db
+			.select((ResourceEnum::Users.to_string(), email.clone()))
+			.await?;
+		match result {
+			Some(response) => Ok(response),
+			None => {
+				bail!("User not found")
+			}
+		}
+	}
+
+	pub async fn query_create_user(&self, data: UsersSchema) -> Result<String> {
+		let db = &self.state.surrealdb;
+		let record: Option<UsersSchema> = db
+			.create((ResourceEnum::Users.to_string(), &data.email))
+			.content(UsersSchema {
+				fullname: data.fullname.clone(),
+				email: data.email.clone(),
+				password: data.password.clone(),
+				is_active: false,
+			})
+			.await?;
+		match record {
+			Some(_) => Ok("Success create user".into()),
+			None => bail!("Failed to create user"),
+		}
+	}
+
+	pub async fn query_active_inactive_user(
+		&self,
+		data: UsersActiveInactiveSchema,
+	) -> Result<String> {
+		let db = &self.state.surrealdb;
+		let record: Option<UsersActiveInactiveSchema> = db
+			.update((ResourceEnum::Users.to_string(), &data.email))
+			.merge(UsersActiveInactiveSchema {
+				email: data.email.clone(),
+				is_active: data.is_active.clone(),
+			})
+			.await?;
+		match record {
+			Some(_) => Ok("Success update user".into()),
+			None => bail!("Failed to update user"),
+		}
+	}
+
+	pub async fn query_update_password_user(
+		&self,
+		data: UsersSetNewPasswordSchema,
+	) -> Result<String> {
+		let db = &self.state.surrealdb;
+		let record: Option<UsersSetNewPasswordSchema> = db
+			.update((ResourceEnum::Users.to_string(), &data.email))
+			.merge(UsersSetNewPasswordSchema {
+				email: data.email.clone(),
+				password: data.password.clone(),
+			})
+			.await?;
+		match record {
+			Some(_) => Ok("Success update password user".into()),
+			None => bail!("Failed to update password user"),
+		}
+	}
+}

src/apps/v1/users/users_schema.rs

@@ -1,10 +1,21 @@
 use serde::{Deserialize, Serialize};
-use utoipa::ToSchema;
 
-#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct UsersSchema {
 	pub email: String,
 	pub fullname: String,
 	pub password: String,
 	pub is_active: bool,
 }
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct UsersSetNewPasswordSchema {
+	pub email: String,
+	pub password: bool,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct UsersActiveInactiveSchema {
+	pub email: String,
+	pub is_active: bool,
+}

src/main.rs

@@ -1,4 +1,4 @@
-use axum_surrealdb_boilerplate::{apps, axum_init};
+use najm_course_api::{apps, axum_init};
 
 #[tokio::main]
 async fn main() {