refactor: add more semantic names to services

src/guards/auth/access_token_guard.rs

@@ -14,7 +14,7 @@ use crate::{
     config::ENV,
     dto::auth::internal::AccessToken,
     enums::errors::external::{Auth, Error},
-    services::device_service::check_logged_in_device,
+    services::device::check_logged_in_device,
     state::AppState,
 };
 

src/guards/auth/refresh_token_guard.rs

@@ -14,7 +14,7 @@ use crate::{
     config::ENV,
     dto::auth::internal::RefreshToken,
     enums::errors::external::{Auth, Error},
-    services::device_service::check_logged_in_device,
+    services::device::check_logged_in_device,
     state::AppState,
 };
 

src/handlers/auth/authorize.rs

@@ -9,15 +9,15 @@ use crate::{
     },
     enums::errors::external::Result,
     extractors::Json,
-    services::user_service,
+    services::user,
     state::AppState,
 };
 
 pub async fn authorize(
     State(state): State<AppState>,
     Json(payload): Json<AuthorizeRequest>,
 ) -> Result<Response<Tokens>> {
-    let tokens = user_service::authorize(
+    let tokens = user::authorize(
         &state,
         &OAuthCode {
             code: payload.code.clone(),

src/handlers/auth/change_password.rs

@@ -9,15 +9,15 @@ use crate::{
     },
     enums::errors::external::Result,
     extractors::Json,
-    services::user_service,
+    services::user,
 };
 
 pub async fn change_password(
     claims: AccessToken,
     State(pool): State<Pool>,
     Json(payload): Json<ChangePasswordRequest>,
 ) -> Result<Response<String>> {
-    user_service::change_password(&pool, &claims.user_id, &payload.password).await?;
+    user::change_password(&pool, &claims.user_id, &payload.password).await?;
 
     info!("Password changed successfully for user: {}", claims.user_id);
 

src/handlers/auth/logout.rs

@@ -5,14 +5,14 @@ use tracing::info;
 use crate::{
     dto::{auth::internal::AccessToken, response::success::Response},
     enums::errors::external::Result,
-    services::device_service,
+    services::device,
 };
 
 pub async fn logout(
     State(pool): State<Pool>,
     access_token: AccessToken,
 ) -> Result<Response<String>> {
-    device_service::logout_device(&pool, &access_token.device_id).await?;
+    device::logout(&pool, &access_token.device_id).await?;
 
     info!("Device logged out: {:?}", access_token.device_id);
 

src/handlers/auth/sign_in.rs

@@ -10,14 +10,14 @@ use crate::{
     },
     enums::errors::external::Result,
     extractors::Json,
-    services::user_service,
+    services::user,
 };
 
 pub async fn sign_in(
     State(pool): State<Pool>,
     Json(payload): Json<SignInRequest>,
 ) -> Result<Response<Tokens>> {
-    let tokens = user_service::sign_in(
+    let tokens = user::sign_in(
         &pool,
         &NewUser {
             email: payload.email.clone(),

src/handlers/auth/sign_up.rs

@@ -10,14 +10,14 @@ use crate::{
     },
     enums::errors::external::Result,
     extractors::Json,
-    services::user_service,
+    services::user,
 };
 
 pub async fn sign_up(
     State(pool): State<Pool>,
     Json(payload): Json<SignUpRequest>,
 ) -> Result<Response<Tokens>> {
-    let tokens = user_service::sign_up(
+    let tokens = user::sign_up(
         &pool,
         &NewUser {
             email: payload.email.clone(),

src/handlers/device/get_devices.rs

@@ -5,14 +5,14 @@ use tracing::info;
 use crate::{
     dto::{auth::internal::AccessToken, device::response::Device, response::success::Response},
     enums::errors::external::Result,
-    services::device_service,
+    services::device,
 };
 
 pub async fn get_devices(
     claims: AccessToken,
     State(pool): State<Pool>,
 ) -> Result<Response<Vec<Device>>> {
-    let devices: Vec<Device> = device_service::get_devices(&pool, &claims.user_id)
+    let devices: Vec<Device> = device::get_many(&pool, &claims.user_id)
         .await?
         .into_iter()
         .map(Device::from)

src/handlers/session/close_session.rs

@@ -5,14 +5,14 @@ use tracing::info;
 use crate::{
     dto::{auth::internal::AccessToken, response::success::Response},
     enums::errors::external::Result,
-    services::session_service,
+    services::session,
 };
 
 pub async fn close_session(
     claims: AccessToken,
     State(pool): State<Pool>,
 ) -> Result<Response<String>> {
-    let session_id = session_service::close_session(&pool, &claims.device_id).await?;
+    let session_id = session::close(&pool, &claims.device_id).await?;
 
     info!("Closed session successfully: {}", session_id);
 

src/handlers/session/create_session.rs

@@ -10,16 +10,15 @@ use crate::{
     },
     enums::errors::external::Result,
     extractors::Json,
-    services::session_service,
+    services::session,
 };
 
 pub async fn create_session(
     claims: AccessToken,
     State(pool): State<Pool>,
     Json(payload): Json<CreateSession>,
 ) -> Result<Response<Session>> {
-    let session =
-        session_service::create_session(&pool, &claims.device_id, &payload.country).await?;
+    let session = session::create(&pool, &claims.device_id, &payload.country).await?;
 
     info!("Session created successfully: {}", session.session_id);
 

src/handlers/session/get_history.rs

@@ -10,7 +10,7 @@ use crate::{
     },
     enums::errors::external::Result,
     extractors::Json,
-    services::session_service,
+    services::session,
 };
 
 pub async fn get_history(
@@ -20,7 +20,7 @@ pub async fn get_history(
 ) -> Result<Response<Vec<SessionHistory>>> {
     info!("Getting session history");
 
-    let history = session_service::get_history(&pool, &claims.user_id, &payload).await?;
+    let history = session::get_history(&pool, &claims.user_id, &payload).await?;
 
     Ok(Response::new(StatusCode::OK, "Successfully got session history").with_data(history))
 }

src/services/config_service/get_config_by_country.rs → src/services/config/get_by_country.rs

@@ -10,7 +10,7 @@ use crate::{
     enums::errors::internal::Result,
 };
 
-pub async fn get_config_by_country(
+pub async fn get_by_country(
     pool: &deadpool_diesel::postgres::Pool,
     country: &Country,
 ) -> Result<(Config, Server)> {

src/services/config/mod.rs

@@ -0,0 +1,3 @@
+mod get_by_country;
+
+pub use get_by_country::get_by_country;

src/services/device_service/add_device.rs → src/services/device/add.rs

@@ -1,21 +1,18 @@
 use diesel::prelude::*;
 use tracing::info;
 
-use super::get_device;
+use super::get;
 use crate::{
     data::{enums::DeviceStatus, models::Device, schema},
     dto::device::internal::NewDevice,
     enums::errors::internal::Result,
 };
 
-pub async fn add_device(
-    pool: &deadpool_diesel::postgres::Pool,
-    new_device: &NewDevice,
-) -> Result<Device> {
+pub async fn add(pool: &deadpool_diesel::postgres::Pool, new_device: &NewDevice) -> Result<Device> {
     let conn = pool.get().await?;
     let new_device = new_device.clone();
 
-    if let Ok(device) = get_device(pool, &new_device).await {
+    if let Ok(device) = get(pool, &new_device).await {
         conn.interact(move |conn| {
             diesel::update(schema::device::table)
                 .filter(schema::device::name.eq(new_device.name))

src/services/device_service/get_device.rs → src/services/device/get.rs

@@ -7,10 +7,7 @@ use crate::{
     enums::errors::internal::Result,
 };
 
-pub async fn get_device(
-    pool: &deadpool_diesel::postgres::Pool,
-    device: &NewDevice,
-) -> Result<Device> {
+pub async fn get(pool: &deadpool_diesel::postgres::Pool, device: &NewDevice) -> Result<Device> {
     let conn = pool.get().await?;
     let device = device.clone();
 

src/services/device_service/get_devices.rs → src/services/device/get_many.rs

@@ -7,7 +7,7 @@ use crate::{
     enums::errors::internal::Result,
 };
 
-pub async fn get_devices(
+pub async fn get_many(
     pool: &deadpool_diesel::postgres::Pool,
     user_id: &Uuid,
 ) -> Result<Vec<Device>> {

src/services/device_service/logout_device.rs → src/services/device/logout.rs

@@ -7,7 +7,7 @@ use crate::{
     enums::errors::internal::Result,
 };
 
-pub async fn logout_device(pool: &deadpool_diesel::postgres::Pool, device_id: &Uuid) -> Result<()> {
+pub async fn logout(pool: &deadpool_diesel::postgres::Pool, device_id: &Uuid) -> Result<()> {
     let conn = pool.get().await?;
     let device_id = *device_id;
 

src/services/device/mod.rs

@@ -0,0 +1,11 @@
+mod add;
+mod check_logged_in;
+mod get;
+mod get_many;
+mod logout;
+
+pub use add::add;
+pub use check_logged_in::check_logged_in_device;
+pub use get::get;
+pub use get_many::get_many;
+pub use logout::logout;

src/services/mod.rs

@@ -1,5 +1,5 @@
-pub mod config_service;
-pub mod device_service;
-pub mod oauth_providers_service;
-pub mod session_service;
-pub mod user_service;
+pub mod config;
+pub mod device;
+pub mod oauth_providers;
+pub mod session;
+pub mod user;

src/services/session_service/close_session.rs → src/services/session/close.rs

@@ -1,22 +1,19 @@
 use uuid::Uuid;
 
-use super::close_session_by_id;
+use super::close_by_id;
 use crate::{
     dto::session::{interface::get_session, query::ActiveSessionAndDevice},
     enums::errors::internal::Result,
 };
 
-pub async fn close_session(
-    pool: &deadpool_diesel::postgres::Pool,
-    device_id: &Uuid,
-) -> Result<Uuid> {
+pub async fn close(pool: &deadpool_diesel::postgres::Pool, device_id: &Uuid) -> Result<Uuid> {
     let (session, _, _, _) = get_session(
         pool,
         ActiveSessionAndDevice {
             device_id: *device_id,
         },
     )
     .await?;
-    let session_id = close_session_by_id(pool, &session.id).await?;
+    let session_id = close_by_id(pool, &session.id).await?;
     Ok(session_id)
 }

src/services/session_service/close_session_by_id.rs → src/services/session/close_by_id.rs

@@ -12,7 +12,7 @@ use crate::{
     enums::errors::internal::{self, Error, Result},
 };
 
-pub async fn close_session_by_id(
+pub async fn close_by_id(
     pool: &deadpool_diesel::postgres::Pool,
     session_id: &Uuid,
 ) -> Result<Uuid> {

src/services/session_service/create_session.rs → src/services/session/create.rs

@@ -2,7 +2,7 @@ use diesel::prelude::*;
 use tracing::info;
 use uuid::Uuid;
 
-use super::close_session_by_id;
+use super::close_by_id;
 use crate::{
     data::{
         enums::{ConfigStatus, Country, SessionStatus},
@@ -16,10 +16,10 @@ use crate::{
         response,
     },
     enums::errors::internal::Result,
-    services::config_service::get_config_by_country,
+    services::config::get_by_country,
 };
 
-pub async fn create_session(
+pub async fn create(
     pool: &deadpool_diesel::postgres::Pool,
     device_id: &Uuid,
     country: &Country,
@@ -40,10 +40,10 @@ pub async fn create_session(
     }
 
     if let Ok((session, _, _, _)) = get_session(pool, ActiveSessionAndDevice { device_id }).await {
-        let _ = close_session_by_id(pool, &session.id).await?;
+        let _ = close_by_id(pool, &session.id).await?;
     }
 
-    let (config, server) = get_config_by_country(pool, &country).await?;
+    let (config, server) = get_by_country(pool, &country).await?;
     let new_session = NewSession {
         status: SessionStatus::Active,
         device_id,

src/services/session/mod.rs

@@ -0,0 +1,9 @@
+mod close;
+mod close_by_id;
+mod create;
+mod get_history;
+
+pub use close::close;
+pub use close_by_id::close_by_id;
+pub use create::create;
+pub use get_history::get_history;

src/services/user_service/authorize.rs → src/services/user/authorize.rs

@@ -10,13 +10,13 @@ use crate::{
         device::internal::{DeviceInfo, NewDevice},
     },
     enums::errors::internal::Result,
-    services::{device_service, oauth_providers_service},
+    services::{device, oauth_providers},
     state::AppState,
     utils::token::generate_tokens,
 };
 
 pub async fn authorize(state: &AppState, code: &OAuthCode, device: &DeviceInfo) -> Result<Tokens> {
-    let oauth_user = oauth_providers_service::authorize_user(state, code).await?;
+    let oauth_user = oauth_providers::authorize_user(state, code).await?;
 
     let current_user = get_by_email(&state.pool, &oauth_user.email).await;
     let user: FullUser;
@@ -40,7 +40,7 @@ pub async fn authorize(state: &AppState, code: &OAuthCode, device: &DeviceInfo)
         user_id: user.user.id,
     };
 
-    let device = device_service::add_device(&state.pool, &device).await?;
+    let device = device::add(&state.pool, &device).await?;
 
     let tokens = generate_tokens(&user.user.id.to_string(), &device.id.to_string()).await?;