Add route params

src/processor.rs

@@ -38,8 +38,9 @@ pub async fn handle_request(
     headers: &Arc<Headers>,
     payload: &mut web::Payload,
     req: &HttpRequest,
+    route_params: HashMap<String, String>,
 ) -> HttpResponse {
-    let contents = match execute_function(function, payload, headers, req).await {
+    let contents = match execute_function(function, payload, headers, req, route_params).await {
         Ok(res) => res,
         Err(err) => {
             println!("Error: {:?}", err);
@@ -74,6 +75,7 @@ async fn execute_function(
     payload: &mut web::Payload,
     headers: &Headers,
     req: &HttpRequest,
+    route_params: HashMap<String, String>,
 ) -> Result<String> {
     let mut data: Option<Vec<u8>> = None;
 
@@ -105,11 +107,22 @@ async fn execute_function(
         PyFunction::CoRoutine(handler) => {
             let output = Python::with_gil(|py| {
                 let handler = handler.as_ref(py);
+                request.insert("params", route_params.into_py(py));
+                request.insert("headers", headers_python.into_py(py));
 
+<<<<<<< HEAD
                 if let Some(res) = data {
                     let data = res.into_py(py);
                     request.insert("body", data);
                     request.insert("headers", headers_python.into_py(py));
+=======
+                match data {
+                    Some(res) => {
+                        let data = res.into_py(py);
+                        request.insert("body", data);
+                    }
+                    None => {}
+>>>>>>> 5ce3932 (Add route params)
                 };
 
                 // this makes the request object to be accessible across every route
@@ -158,11 +171,13 @@ async fn execute_function(
             tokio::task::spawn_blocking(move || {
                 Python::with_gil(|py| {
                     let handler = handler.as_ref(py);
+                    request.insert("params", route_params.into_py(py));
+                    request.insert("headers", headers_python.into_py(py));
                     let output: PyResult<&PyAny> = match data {
                         Some(res) => {
                             let data = res.into_py(py);
                             request.insert("body", data);
-                            request.insert("headers", headers_python.into_py(py));
+
                             handler.call1((request,))
                         }
                         None => handler.call1((request,)),

src/router.rs

@@ -1,4 +1,4 @@
-use dashmap::DashMap;
+use std::collections::HashMap;
 use std::sync::{Arc, RwLock};
 // pyo3 modules
 use crate::types::PyFunction;
@@ -84,10 +84,22 @@ impl Router {
             .unwrap();
     }
 
-    pub fn get_route(&self, route_method: Method, route: &str) -> Option<PyFunction> {
+    pub fn get_route(
+        &self,
+        route_method: Method,
+        route: &str,
+    ) -> Option<(PyFunction, HashMap<String, String>)> {
         let table = self.get_relevant_map(route_method)?;
         match table.read().unwrap().at(route) {
-            Ok(res) => Some(res.value.clone()),
+            Ok(res) => {
+                let mut route_params = HashMap::new();
+
+                for (key, value) in res.params.iter() {
+                    route_params.insert(key.to_string(), value.to_string());
+                }
+
+                Some((res.value.clone(), route_params))
+            }
             Err(_) => None,
         }
     }

src/server.rs

@@ -164,8 +164,8 @@ async fn index(
     req: HttpRequest,
 ) -> impl Responder {
     match router.get_route(req.method().clone(), req.uri().path()) {
-        Some(handler_function) => {
-            handle_request(handler_function, &headers, &mut payload, &req).await
+        Some((handler_function, route_params)) => {
+            handle_request(handler_function, &headers, &mut payload, &req, route_params).await
         }
         None => {
             let mut response = HttpResponse::Ok();

test_python/base_routes.py

@@ -22,14 +22,15 @@ async def h(request):
 
 @app.get("/test/:id")
 async def test(request):
+    print(request)
     return static_file("./index.html")
 
 @app.get("/jsonify")
 async def json_get(request):
     return jsonify({"hello": "world"})
 
 
-@app.post("/jsonify")
+@app.post("/jsonify/:id")
 async def json(request):
     print(request)
     return jsonify({"hello": "world"})