use std::{fmt, marker::PhantomData};
use crate::service::{BindCtx, Ctx, Middleware, Service};
use crate::web::{State, WebError, WebRequest, WebResponse, WebResponseError};
pub fn from_fn<F, S, St, In>(f: F) -> FromFn<F, S, St, In>
where
St: State,
F: AsyncFn(WebRequest<In>, Next<'_, S, St>) -> Result<WebResponse, WebError<St, St::Error>>
+ Clone,
{
FromFn { f, _t: PhantomData }
}
pub struct FromFn<F, S, St, In = ()> {
f: F,
_t: PhantomData<fn(S, St, In)>,
}
impl<F: Clone, S, St, In> Clone for FromFn<F, S, St, In> {
fn clone(&self) -> Self {
FromFn {
f: self.f.clone(),
_t: PhantomData,
}
}
}
impl<F, S, St, In> fmt::Debug for FromFn<F, S, St, In> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("FromFn")
.field("f", &std::any::type_name::<F>())
.finish()
}
}
impl<F, S, St, In> Middleware<S, St> for FromFn<F, S, St, In>
where
St: State,
S: Service<St, WebRequest<In>, Res = WebResponse>,
S::Error: WebResponseError<St, St::Error>,
F: AsyncFn(WebRequest<In>, Next<'_, S, St>) -> Result<WebResponse, WebError<St, St::Error>>
+ Clone,
{
type Service = FromFnService<F, S>;
fn create(&self, _: &St, svc: S) -> Self::Service {
FromFnService {
f: self.f.clone(),
svc,
}
}
}
pub struct FromFnService<F, S> {
f: F,
svc: S,
}
impl<F, S: fmt::Debug> fmt::Debug for FromFnService<F, S> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("FromFnService")
.field("svc", &self.svc)
.field("f", &std::any::type_name::<F>())
.finish()
}
}
impl<F, S, St, In> Service<St, WebRequest<In>> for FromFnService<F, S>
where
St: State,
S: Service<St, WebRequest<In>, Res = WebResponse>,
S::Error: WebResponseError<St, St::Error>,
F: AsyncFn(WebRequest<In>, Next<'_, S, St>) -> Result<WebResponse, WebError<St, St::Error>>,
{
type Res = WebResponse;
type Error = WebError<St, St::Error>;
async fn call(
&self,
req: WebRequest<In>,
ctx: Ctx<'_, Self, St>,
) -> Result<Self::Res, Self::Error> {
ctx.call(&NextService(&self.svc), (req, &self.f)).await
}
fn bind(&self, ctx: BindCtx<'_>) {
ctx.bind::<_, St, _>(&self.svc);
}
async fn ready(&self, ctx: Ctx<'_, Self, St>) -> Result<(), Self::Error> {
ctx.ready(&self.svc).await.map_err(WebError::from_err)
}
async fn shutdown(&self, ctx: Ctx<'_, Self, St>) {
ctx.shutdown(&self.svc).await;
}
}
pub struct Next<'a, S, St> {
svc: &'a S,
ctx: Ctx<'a, NextService<'a, S>, St>,
}
impl<S, St> fmt::Debug for Next<'_, S, St> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Next").finish()
}
}
impl<S, St: State> Next<'_, S, St> {
pub async fn call<In>(
&self,
req: WebRequest<In>,
) -> Result<WebResponse, WebError<St, St::Error>>
where
S: Service<St, WebRequest<In>, Res = WebResponse>,
S::Error: WebResponseError<St, St::Error>,
{
self.ctx
.call(self.svc, req)
.await
.map_err(WebError::from_err)
}
pub fn st(&self) -> &St {
self.ctx.st()
}
}
struct NextService<'a, S>(&'a S);
impl<'f, F, S, St, In> Service<St, (WebRequest<In>, &'f F)> for NextService<'_, S>
where
St: State,
S: Service<St, WebRequest<In>, Res = WebResponse>,
S::Error: WebResponseError<St, St::Error>,
F: AsyncFn(WebRequest<In>, Next<'_, S, St>) -> Result<WebResponse, WebError<St, St::Error>>,
{
type Res = WebResponse;
type Error = WebError<St, St::Error>;
async fn call(
&self,
(req, f): (WebRequest<In>, &'f F),
ctx: Ctx<'_, Self, St>,
) -> Result<Self::Res, Self::Error> {
f(req, Next { svc: self.0, ctx }).await
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::StatusCode;
use crate::http::header::{CONTENT_TYPE, HeaderName, HeaderValue};
use crate::web::test::{TestRequest, call_service, init_service, init_service_st};
use crate::web::{self, App, AppState, HttpResponse, error, middleware::DefaultHeaders};
#[crate::rt_test]
async fn from_fn_infers_and_stacks() {
let srv = init_service(
App::new()
.middleware(from_fn(async |req, next| {
if req.path() == "/skip" {
return Ok(req.into_response(HttpResponse::Forbidden().build()));
}
let mut res = next.call(req).await?;
res.headers_mut()
.insert(CONTENT_TYPE, HeaderValue::from_static("app"));
Ok(res)
}))
.middleware(DefaultHeaders::new().header("x-a", "1"))
.middleware(from_fn(async |req, next| next.call(req).await))
.service(
web::scope("/s")
.middleware(from_fn(async |req, next| {
let mut res = next.call(req).await?;
res.headers_mut().insert(
HeaderName::from_static("x-scope"),
HeaderValue::from_static("1"),
);
Ok(res)
}))
.service(
web::resource("/r")
.middleware(from_fn(async |req, next| {
let mut res = next.call(req).await?;
res.headers_mut().insert(
HeaderName::from_static("x-res"),
HeaderValue::from_static("1"),
);
Ok(res)
}))
.to(async || HttpResponse::Ok()),
),
)
.route("/test", web::get().to(async || HttpResponse::Ok())),
)
.await;
let res = call_service(&srv, TestRequest::with_uri("/test").to_request()).await;
assert_eq!(res.status(), StatusCode::OK);
assert_eq!(res.headers().get(CONTENT_TYPE).unwrap(), "app");
let res = call_service(&srv, TestRequest::with_uri("/skip").to_request()).await;
assert_eq!(res.status(), StatusCode::FORBIDDEN);
let res = call_service(&srv, TestRequest::with_uri("/s/r").to_request()).await;
assert_eq!(res.headers().get("x-scope").unwrap(), "1");
assert_eq!(res.headers().get("x-res").unwrap(), "1");
assert_eq!(res.headers().get("x-a").unwrap(), "1");
}
#[crate::rt_test]
async fn from_fn_returns_error() {
let srv = init_service(
App::new()
.middleware(from_fn(async |req, next| {
if !req.headers().contains_key("authorization") {
return Err(WebError::from_err(error::ErrorUnauthorized("no auth")));
}
next.call(req).await
}))
.route("/test", web::get().to(async || HttpResponse::Ok())),
)
.await;
let res = call_service(&srv, TestRequest::with_uri("/test").to_request()).await;
assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
let req = TestRequest::with_uri("/test")
.header("authorization", "x")
.to_request();
let res = call_service(&srv, req).await;
assert_eq!(res.status(), StatusCode::OK);
}
#[crate::rt_test]
async fn from_fn_reads_state() {
let srv = init_service_st(
AppState::new("st"),
App::<AppState<&'static str>>::new()
.middleware(from_fn(async |req, next: Next<'_, _, AppState<&str>>| {
let tag = **next.st();
let mut res = next.call(req).await?;
res.headers_mut().insert(
HeaderName::from_static("x-st"),
HeaderValue::from_static(tag),
);
Ok(res)
}))
.route("/test", web::get().to(async || HttpResponse::Ok())),
)
.await;
let res = call_service(&srv, TestRequest::with_uri("/test").to_request()).await;
assert_eq!(res.headers().get("x-st").unwrap(), "st");
}
}