titan 0.4.2

Titan is a web-framework, SSR engine with css-in-rust support, http server and http router.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use crate::utils::BoxCloneService;

#[cfg(feature = "types")]
pub use crate::types::*;

macro_rules! impl_method {
  ($( $method_name:ident $method:ident ),*) => {
            $(
    pub fn $method_name<H, Args>(handler: H) -> $crate::endpoint::Endpoint
    where
      H: titan_core::Handler<Args> + Sync + Clone,
      H::Future: std::future::Future<Output = H::Output> + Send,
      H::Output: titan_core::Respondable,
      Args: titan_core::FromRequest + Send + Sync + 'static,
      Args::Error: Send

    {
      let mut methods = std::collections::HashMap::default();
      let route = $crate::route::Route::new(handler);

      methods.insert(titan_http::Method::$method, BoxCloneService::new(route));
      $crate::endpoint::Endpoint { methods }
    }
            )*
  };
}

pub fn any<H, Args>(handler: H) -> crate::endpoint::Endpoint
where
  H: titan_core::Handler<Args> + Sync + Clone,
  H::Future: std::future::Future<Output = H::Output> + Send,
  H::Output: titan_core::Respondable,
  Args: titan_core::FromRequest + Send + Sync + 'static,
  Args::Error: Send,
{
  let mut methods = std::collections::HashMap::default();
  let route = crate::route::Route::new(handler);

  methods.insert(titan_http::Method::GET, BoxCloneService::new(route.clone()));
  methods.insert(titan_http::Method::POST, BoxCloneService::new(route.clone()));
  methods.insert(titan_http::Method::PUT, BoxCloneService::new(route.clone()));
  methods
    .insert(titan_http::Method::DELETE, BoxCloneService::new(route.clone()));
  methods.insert(titan_http::Method::PATCH, BoxCloneService::new(route));
  crate::endpoint::Endpoint { methods }
}

impl_method!(get GET, post POST, put PUT, delete DELETE, patch PATCH);

//pub fn with_guard<G, T>(guard: G, service: T) -> GuardLayerService<T>
//where
//  G: Guard + 'static,
//  T: Service<Request>,
//{
//  GuardLayerService { guard: Box::new(guard), service }
//}

//pub struct GuardLayerService<S> {
//  guard: Box<dyn Guard>,
//  service: S,
//}

//impl<S> Service<Request> for GuardLayerService<S>
//where
//  S: Service<Request, Response = Response, Error = Response>,
//  S::Future: 'static + Send,
//{
//  type Response = Response;
//  type Error = Response;
//  type Future = BoxedSendFuture<Result<Self::Response, Self::Error>>;
//  fn poll_ready(
//    &mut self,
//    cx: &mut std::task::Context<'_>,
//  ) -> std::task::Poll<Result<(), Self::Error>> {
//    self.service.poll_ready(cx).map_err(|err| err.respond())
//  }
//
//  fn call(&mut self, req: Request) -> Self::Future {
//    let (parts, body) = req.into_parts();
//    let result = self.guard.check(&parts);
//
//    match result {
//      crate::guard::GuardOutcome::Reason(reason) => {
//        Box::pin(async move { Ok(Response::from(reason)) })
//      }
//      crate::guard::GuardOutcome::WeJustPassinBy => {
//        let req = Request::from_parts(parts, body);
//        Box::pin(self.service.call(req))
//      }
//    }
//  }
//}