update enum name and location

src/routers/middleware_router.rs

@@ -9,7 +9,7 @@ use matchit::Node;
 
 use anyhow::{bail, Error, Result};
 
-use super::router::RouteType;
+use super::types::MiddlewareRouteType;
 
 /// Contains the thread safe hashmaps of different routes
 
@@ -27,18 +27,21 @@ impl MiddlewareRouter {
     }
 
     #[inline]
-    fn get_relevant_map(&self, route: RouteType) -> Option<&RwLock<Node<(PyFunction, u8)>>> {
+    fn get_relevant_map(
+        &self,
+        route: MiddlewareRouteType,
+    ) -> Option<&RwLock<Node<(PyFunction, u8)>>> {
         match route {
-            RouteType::BeforeRequest => Some(&self.before_request),
-            RouteType::AfterRequest => Some(&self.after_request),
+            MiddlewareRouteType::BeforeRequest => Some(&self.before_request),
+            MiddlewareRouteType::AfterRequest => Some(&self.after_request),
         }
     }
 
     // Checks if the functions is an async function
     // Inserts them in the router according to their nature(CoRoutine/SyncFunction)
     pub fn add_route(
         &self,
-        route_type: RouteType, // we can just have route type as WS
+        route_type: MiddlewareRouteType, // we can just have route type as WS
         route: &str,
         handler: Py<PyAny>,
         is_async: bool,
@@ -65,7 +68,7 @@ impl MiddlewareRouter {
 
     pub fn get_route(
         &self,
-        route_method: RouteType,
+        route_method: MiddlewareRouteType,
         route: &str, // check for the route method here
     ) -> Option<((PyFunction, u8), HashMap<String, String>)> {
         // need to split this function in multiple smaller functions

src/routers/mod.rs

@@ -1,4 +1,5 @@
 pub mod const_router;
 pub mod middleware_router;
 pub mod router;
+pub mod types;
 pub mod web_socket_router;

src/routers/router.rs

@@ -10,22 +10,6 @@ use matchit::Node;
 
 use anyhow::{bail, Error, Result};
 
-#[derive(Debug)]
-pub enum RouteType {
-    BeforeRequest,
-    AfterRequest,
-}
-
-impl RouteType {
-    pub fn from_str(input: &str) -> RouteType {
-        match input {
-            "BEFORE_REQUEST" => RouteType::BeforeRequest,
-            "AFTER_REQUEST" => RouteType::AfterRequest,
-            _ => panic!("Invalid route type enum."),
-        }
-    }
-}
-
 /// Contains the thread safe hashmaps of different routes
 
 pub struct Router {

src/routers/types.rs

@@ -0,0 +1,15 @@
+#[derive(Debug)]
+pub enum MiddlewareRouteType {
+    BeforeRequest,
+    AfterRequest,
+}
+
+impl MiddlewareRouteType {
+    pub fn from_str(input: &str) -> MiddlewareRouteType {
+        match input {
+            "BEFORE_REQUEST" => MiddlewareRouteType::BeforeRequest,
+            "AFTER_REQUEST" => MiddlewareRouteType::AfterRequest,
+            _ => panic!("Invalid route type enum."),
+        }
+    }
+}

src/server.rs

@@ -4,7 +4,8 @@ use crate::request_handler::{handle_http_middleware_request, handle_http_request
 
 use crate::routers::const_router::ConstRouter;
 
-use crate::routers::router::{RouteType, Router};
+use crate::routers::router::Router;
+use crate::routers::types::MiddlewareRouteType;
 use crate::routers::{middleware_router::MiddlewareRouter, web_socket_router::WebSocketRouter};
 use crate::shared_socket::SocketHeld;
 use crate::types::{Headers, PyFunction};
@@ -302,7 +303,7 @@ impl Server {
     ) {
         debug!("MiddleWare Route added for {} {} ", route_type, route);
 
-        let route_type = RouteType::from_str(route_type);
+        let route_type = MiddlewareRouteType::from_str(route_type);
 
         self.middleware_router
             .add_route(route_type, route, handler, is_async, number_of_params)
@@ -397,24 +398,24 @@ async fn index(
     let headers = merge_headers(&global_headers, req.headers()).await;
 
     // need a better name for this
-    let tuple_params = match middleware_router.get_route(RouteType::BeforeRequest, req.uri().path())
-    {
-        Some(((handler_function, number_of_params), route_params)) => {
-            let x = handle_http_middleware_request(
-                handler_function,
-                number_of_params,
-                &headers,
-                &mut payload,
-                &req,
-                route_params,
-                queries.clone(),
-            )
-            .await;
-            debug!("Middleware contents {:?}", x);
-            x
-        }
-        None => HashMap::new(),
-    };
+    let tuple_params =
+        match middleware_router.get_route(MiddlewareRouteType::BeforeRequest, req.uri().path()) {
+            Some(((handler_function, number_of_params), route_params)) => {
+                let x = handle_http_middleware_request(
+                    handler_function,
+                    number_of_params,
+                    &headers,
+                    &mut payload,
+                    &req,
+                    route_params,
+                    queries.clone(),
+                )
+                .await;
+                debug!("Middleware contents {:?}", x);
+                x
+            }
+            None => HashMap::new(),
+        };
 
     debug!("These are the tuple params {:?}", tuple_params);
 
@@ -460,7 +461,7 @@ async fn index(
     };
 
     if let Some(((handler_function, number_of_params), route_params)) =
-        middleware_router.get_route(RouteType::AfterRequest, req.uri().path())
+        middleware_router.get_route(MiddlewareRouteType::AfterRequest, req.uri().path())
     {
         let x = handle_http_middleware_request(
             handler_function,