feature: add method and body to route params

1 files changed, 79 insertions, 20 deletions

diff --git a/src/server.rs b/src/server.rs
index 16b543e..307aa0c 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -5,16 +5,16 @@ use std::path::PathBuf;
 use std::pin::Pin;
 use std::sync::{Arc, Mutex};
 
-use http_body_util::Full;
+use http_body_util::{BodyExt, Collected, Full};
 use hyper::body::{Bytes, Incoming};
 use hyper::server::conn::http1;
 use hyper::service::Service;
-use hyper::{Request, Response, StatusCode};
+use hyper::{Method, Request, Response, StatusCode};
 use hyper_util::rt::TokioIo;
 use tokio::net::TcpListener;
 
 use crate::error::ReluaxError;
-use crate::luax::table_to_html;
+use crate::luax::{table_to_html, table_to_json};
 use color_eyre::Result;
 use rlua::Lua;
 
@@ -88,6 +88,57 @@ fn mk_file_response(path: PathBuf) -> Result<Response<Full<Bytes>>> {
         .body(Full::new(Bytes::from(bytes)))?)
 }
 
+fn decode_luax_response(status: StatusCode, t: rlua::Table) -> Result<Response<Full<Bytes>>> {
+    if t.contains_key("type")? {
+        let ty: String = t.get("type")?;
+        let mime_type: Option<String> = t.get("mime_type")?;
+
+        match ty.as_str() {
+            "html" => {
+                let html: rlua::Table = t.get("value")?;
+                let mut buf = Vec::new();
+                table_to_html(html, &mut buf)?;
+                Ok(Response::builder()
+                    .header("Content-Type", mime_type.unwrap_or("text/html".to_string()))
+                    .status(status)
+                    .body(Full::new(Bytes::from(buf)))?)
+            }
+            "json" => {
+                let json: rlua::Table = t.get("value")?;
+                let mut buf = Vec::new();
+                table_to_json(json, &mut buf)?;
+
+                Ok(Response::builder()
+                    .header(
+                        "Content-Type",
+                        mime_type.unwrap_or("application/json".to_string()),
+                    )
+                    .status(status)
+                    .body(Full::new(Bytes::from(buf)))?)
+            }
+            "html-page" => {
+                let html: rlua::Table = t.get("value")?;
+                let mut buf = Vec::new();
+                writeln!(&mut buf, "<!DOCTYPE html>")?;
+                table_to_html(html, &mut buf)?;
+                Ok(Response::builder()
+                    .header("Content-Type", mime_type.unwrap_or("text/html".to_string()))
+                    .status(status)
+                    .body(Full::new(Bytes::from(buf)))?)
+            }
+            _ => Err(ReluaxError::Server("Unknown response type".to_string()).into()),
+        }
+    } else {
+        let mut buf = Vec::new();
+        writeln!(&mut buf, "<!DOCTYPE html>")?;
+        table_to_html(t, &mut buf)?;
+        Ok(Response::builder()
+            .header("Content-Type", "text/html")
+            .status(status)
+            .body(Full::new(Bytes::from(buf)))?)
+    }
+}
+
 impl Service<Request<Incoming>> for State {
     type Response = Response<Full<Bytes>>;
     type Error = color_eyre::Report;
@@ -95,16 +146,27 @@ impl Service<Request<Incoming>> for State {
         Pin<Box<dyn Future<Output = std::result::Result<Self::Response, Self::Error>> + Send>>;
 
     fn call(&self, req: Request<Incoming>) -> Self::Future {
-        let path = req.uri().path();
-        let res = self.serve(path);
+        let path = req.uri().path().to_string();
+        let method = req.method().clone();
+        let lua = self.lua.clone();
+        let public_dir = self.public_dir.clone();
+        Box::pin(async {
+            let body = req.into_body().collect().await?;
 
-        Box::pin(async { res })
+            Self::serve(lua, public_dir, path, method, body)
+        })
     }
 }
 
 impl State {
-    fn serve(&self, path: &str) -> Result<Response<Full<Bytes>>> {
-        let lua = self.lua.lock().unwrap();
+    fn serve(
+        lua: Arc<Mutex<Lua>>,
+        public_dir: Option<PathBuf>,
+        path: String,
+        method: Method,
+        body: Collected<Bytes>,
+    ) -> Result<Response<Full<Bytes>>> {
+        let lua = lua.lock().unwrap();
 
         let res = lua.context(|ctx| -> Result<Response<Full<Bytes>>> {
             let manifest: rlua::Result<rlua::Table> = ctx.load("require('reluax')").eval();
@@ -123,7 +185,11 @@ impl State {
 
             let route: rlua::Function = manifest.get("route")?;
 
-            let res: rlua::Result<(rlua::Integer, rlua::Value)> = route.call((path,));
+            let method = method.as_str();
+            let body: Vec<u8> = body.to_bytes().to_vec();
+
+            let res: rlua::Result<(rlua::Integer, rlua::Value)> =
+                route.call((path.clone(), method, body));
 
             let res = match res {
                 Ok(r) => r,
@@ -132,7 +198,7 @@ impl State {
 
                     return mk_response(
                         StatusCode::INTERNAL_SERVER_ERROR,
-                        "Internal lua error".to_string(),
+                        "Internal server error".to_string(),
                     );
                 }
             };
@@ -140,10 +206,9 @@ impl State {
             let status =
                 StatusCode::from_u16(res.0 as u16).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
 
-            if status == StatusCode::NOT_FOUND && self.public_dir.is_some() {
+            if status == StatusCode::NOT_FOUND && public_dir.is_some() {
                 // try to serve a static file
-                let path = self
-                    .public_dir
+                let path = public_dir
                     .clone()
                     .unwrap()
                     .join(path.trim_start_matches('/'));
@@ -155,13 +220,7 @@ impl State {
 
             match res.1 {
                 rlua::Value::String(s) => mk_response(status, s.to_str()?.to_string()),
-                rlua::Value::Table(t) => {
-                    let mut buf = Vec::new();
-                    writeln!(&mut buf, "<!DOCTYPE html>")?;
-                    table_to_html(t, &mut buf)?;
-                    let s = String::from_utf8(buf).unwrap();
-                    mk_response(status, s)
-                }
+                rlua::Value::Table(t) => decode_luax_response(status, t),
                 rlua::Value::Nil => Err(ReluaxError::Server("No route found".to_string()).into()),
                 rlua::Value::Error(e) => Err(ReluaxError::Lua(e).into()),
                 _ => Err(ReluaxError::Server("Route returned invalid type".to_string()).into()),