use std::{marker::PhantomData, sync::Arc};
use matchit::Router;
use crate::http::{http_request::HttpRequest, http_response::HttpResponse, server::{http_server::{HttpServer, HttpServerError, RequestMiddlewareCallback, ResponseMiddlewareCallback, RouteCallback}, http_server_config::HttpServerConfig}};
pub struct Before;
pub struct Route;
pub struct After;
pub struct HttpServerBuilder<State> {
config: HttpServerConfig,
router: Router<RouteCallback>,
request_middleware: Vec<RequestMiddlewareCallback>,
response_middleware: Vec<ResponseMiddlewareCallback>,
_state: PhantomData<State>
}
impl HttpServerBuilder<Before> {
pub fn new(config: HttpServerConfig) -> Self {
Self {
config: config,
router: Router::new(),
request_middleware: Vec::new(),
response_middleware: Vec::new(),
_state: PhantomData
}
}
pub fn request_middleware<T, Fut>(mut self, callback: T) -> Self
where
T: Fn(HttpRequest) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Result<HttpRequest, HttpResponse>> + Send + 'static
{
let callback = Arc::new(callback);
self.request_middleware.push(Arc::new(move |request| {
let callback = Arc::clone(&callback);
Box::pin(async move {
callback(request).await
})
}));
self
}
pub fn route<T, Fut>(mut self, path: impl Into<String>, callback: T) -> HttpServerBuilder<Route>
where
T: Fn(HttpRequest) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Result<HttpResponse, HttpServerError>> + Send + 'static,
{
self.router.insert(path.into(), Arc::new(move |request| Box::pin(callback(request)))).unwrap();
HttpServerBuilder {
config: self.config,
router: self.router,
request_middleware: self.request_middleware,
response_middleware: self.response_middleware,
_state: PhantomData
}
}
}
impl HttpServerBuilder<Route> {
pub fn route<T, Fut>(mut self, path: impl Into<String>, callback: T) -> Self
where
T: Fn(HttpRequest) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Result<HttpResponse, HttpServerError>> + Send + 'static,
{
self.router.insert(path.into(), Arc::new(move |request| Box::pin(callback(request)))).unwrap();
self
}
pub fn response_middleware<T, Fut>(mut self, callback: T) -> HttpServerBuilder<After>
where
T: Fn(HttpResponse) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Result<HttpResponse, HttpServerError>> + Send + 'static,
{
self.response_middleware.push(Arc::new(move |response| Box::pin(callback(response))));
HttpServerBuilder {
config: self.config,
router: self.router,
request_middleware: self.request_middleware,
response_middleware: self.response_middleware,
_state: PhantomData
}
}
pub fn build(self) -> HttpServer {
HttpServer::new(self.config, self.router, self.request_middleware, self.response_middleware)
}
}
impl HttpServerBuilder<After> {
pub fn build(self) -> HttpServer {
HttpServer::new(self.config, self.router, self.request_middleware, self.response_middleware)
}
}