Implements CORS

Cargo.lock

@@ -977,6 +977,7 @@ dependencies = [
  "serde_json",
  "serde_with",
  "tokio",
+ "tower-http",
  "uuid",
 ]
 
@@ -1817,6 +1818,22 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "tower-http"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5"
+dependencies = [
+ "bitflags 2.4.2",
+ "bytes",
+ "http 1.0.0",
+ "http-body 1.0.0",
+ "http-body-util",
+ "pin-project-lite",
+ "tower-layer",
+ "tower-service",
+]
+
 [[package]]
 name = "tower-layer"
 version = "0.3.2"

Cargo.toml

@@ -21,3 +21,4 @@ dotenv = "0.15.0"
 log = "0.4.20"
 lettre = { version = "0.11.4", default-features = false, features = ["smtp-transport", "tokio1-rustls-tls", "hostname", "builder"] }
 redis = { version = "0.24.0", features = ["aio", "tokio-comp"] }
+tower-http = { version = "0.5.2", features = ["cors"] }

src/config/config_server.rs

@@ -1,22 +1,31 @@
 use cached::proc_macro::cached;
 
-
 #[derive(Clone)]
 pub struct ConfigServer {
-    pub(crate) host: String,
-    pub(crate) port: u16,
+    pub host: String,
+    pub port: u16,
+    pub allowed_origins: Option<Vec<String>>,
 }
 
 #[cached]
 pub fn get_config_server() -> ConfigServer {
     dotenv::dotenv().ok();
 
-    let h = option_env!("HOST").unwrap_or("localhost").to_string();
+    let host = option_env!("HOST").unwrap_or("localhost").to_string();
 
-    let p = option_env!("PORT")
+    let port = option_env!("PORT")
         .unwrap_or("8500")
         .parse::<u16>()
         .unwrap();
 
-    ConfigServer { host: h, port: p }
+    let allowed_origins = match option_env!("ALLOWED_ORIGINS") {
+        Some(origins) => Some(origins.split(",").map(|s| s.to_string()).collect()),
+        None => None,
+    };
+
+    ConfigServer {
+        host,
+        port,
+        allowed_origins,
+    }
 }

src/main.rs

@@ -13,7 +13,7 @@ use crate::config::config_server;
 async fn main() {
     let server_config = config_server::get_config_server();
 
-    let app = route::create_route();
+    let app = route::create_route(server_config.allowed_origins);
 
     println!("🚀 Server started successfully");
     let listener =

src/route.rs

@@ -1,11 +1,9 @@
-
 use crate::depends::depends_auth_service::get_depends_auth_service;
 use crate::depends::depends_email_service::get_depends_email_service;
 use crate::handler::health::health_check;
 use crate::handler::message::send_message;
 use crate::middleware::auth_middleware::auth_middleware;
 
-
 use crate::utils::router_builder::RouterBuilder;
 use axum::{
     middleware,
@@ -25,9 +23,10 @@ fn configure_health_endpoint(router: Router) -> Router {
     router.route("/health", get(health_check))
 }
 
-pub fn create_route() -> Router {
+pub fn create_route(allowed_origins: Option<Vec<String>>) -> Router {
     RouterBuilder::new()
         .add_config(configure_message_endpoint)
         .add_config(configure_health_endpoint)
+        .add_cors(allowed_origins)
         .build()
 }

src/service/auth_service.rs

@@ -5,7 +5,6 @@ use crate::model::send_message::MessageAuthor;
 use redis::{AsyncCommands, ExistenceCheck, SetExpiry, SetOptions};
 use reqwest::header::AUTHORIZATION;
 
-
 #[derive(Clone)]
 pub struct AuthService {
     auth_url: String,

src/service/email_service.rs

@@ -1,5 +1,5 @@
 use crate::config::config_email::ConfigEmail;
-use crate::model::send_message::{SendMessage};
+use crate::model::send_message::SendMessage;
 use lettre::message::Mailbox;
 use lettre::{
     transport::smtp::authentication::Credentials, Address, AsyncSmtpTransport, AsyncTransport,

src/utils/router_builder.rs

@@ -1,4 +1,6 @@
 use axum::Router;
+use http::Method;
+use tower_http::cors::{AllowOrigin, CorsLayer};
 
 pub struct RouterBuilder {
     router: Router,
@@ -16,6 +18,17 @@ impl RouterBuilder {
         return self;
     }
 
+    pub fn add_cors(&mut self, allowed_origins: Option<Vec<String>>) -> &mut Self {
+        let cors = CorsLayer::new()
+            .allow_methods([Method::GET, Method::POST, Method::OPTIONS])
+            .allow_origin(allowed_origins.map_or(AllowOrigin::any(), |origins| {
+                AllowOrigin::list(origins.iter().map(|s| s.parse().unwrap()))
+            }));
+
+        self.router = self.router.clone().layer(cors);
+        return self;
+    }
+
     pub fn build(&self) -> Router {
         self.router.clone()
     }