use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context, Poll};
use ::axum::extract::{FromRef, FromRequestParts};
use ::axum::http::request::Parts;
use ::axum::http::{HeaderMap, Request, StatusCode};
use ::axum::response::{IntoResponse, Response};
use tower::{Layer, Service};
use crate::{Forbidden, Provider, Role, Unauthorized, User, Verifier, Webhook};
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum Rejection {
#[error(transparent)]
Unauthorized(#[from] Unauthorized),
#[error(transparent)]
Forbidden(#[from] Forbidden),
}
impl IntoResponse for Rejection {
fn into_response(self) -> Response {
let (status, body) = match self {
Self::Unauthorized(_) => (StatusCode::UNAUTHORIZED, "unauthorized".to_owned()),
Self::Forbidden(Forbidden(least)) => (StatusCode::FORBIDDEN, format!("forbidden: this needs {least}")),
};
(status, [("cache-control", "no-store")], body).into_response()
}
}
impl<S> FromRequestParts<S> for User
where
S: Send + Sync,
Verifier: FromRef<S>,
{
type Rejection = Rejection;
async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
if let Some(Vouched(user)) = parts.extensions.get::<Vouched>() {
return Ok(user.clone());
}
Ok(Verifier::from_ref(state).require_user(&parts.headers).await?)
}
}
#[derive(Clone)]
struct Vouched(User);
#[derive(Clone)]
pub struct Jiayang {
verifier: Verifier,
least: Option<Role>,
}
impl Jiayang {
pub fn new(verifier: Verifier) -> Self {
Self { verifier, least: None }
}
#[must_use]
pub fn requires(mut self, least: Role) -> Self {
self.least = Some(least);
self
}
async fn check(&self, headers: &HeaderMap) -> Result<User, Rejection> {
let user = self.verifier.require_user(headers).await?;
if let Some(least) = self.least {
user.require_role(least)?;
}
Ok(user)
}
}
impl<S> Layer<S> for Jiayang {
type Service = Verified<S>;
fn layer(&self, inner: S) -> Self::Service {
Verified { inner, jiayang: self.clone() }
}
}
#[derive(Clone)]
pub struct Verified<S> {
inner: S,
jiayang: Jiayang,
}
impl<S, B> Service<Request<B>> for Verified<S>
where
S: Service<Request<B>, Response = Response> + Clone + Send + 'static,
S::Future: Send + 'static,
B: Send + 'static,
{
type Response = Response;
type Error = S::Error;
type Future = Pin<Box<dyn Future<Output = Result<Response, Self::Error>> + Send>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.inner.poll_ready(cx)
}
fn call(&mut self, mut request: Request<B>) -> Self::Future {
let spare = self.inner.clone();
let mut ready = std::mem::replace(&mut self.inner, spare);
let jiayang = self.jiayang.clone();
Box::pin(async move {
match jiayang.check(request.headers()).await {
Ok(user) => {
request.extensions_mut().insert(Vouched(user));
ready.call(request).await
}
Err(refusal) => Ok(refusal.into_response()),
}
})
}
}
impl<S> FromRequestParts<S> for Webhook
where
S: Send + Sync,
{
type Rejection = Rejection;
async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
match parts.extensions.get::<VouchedWebhook>() {
Some(VouchedWebhook(webhook)) => Ok(webhook.clone()),
None => Err(Unauthorized("no verified webhook").into()),
}
}
}
#[derive(Clone)]
struct VouchedWebhook(Webhook);
#[derive(Clone)]
pub struct JiayangWebhook {
verifier: Verifier,
providers: Arc<[Provider]>,
}
impl JiayangWebhook {
pub fn new(verifier: Verifier, providers: impl IntoIterator<Item = Provider>) -> Self {
Self { verifier, providers: providers.into_iter().collect() }
}
}
impl<S> Layer<S> for JiayangWebhook {
type Service = VerifiedWebhook<S>;
fn layer(&self, inner: S) -> Self::Service {
VerifiedWebhook { inner, layer: self.clone() }
}
}
#[derive(Clone)]
pub struct VerifiedWebhook<S> {
inner: S,
layer: JiayangWebhook,
}
impl<S, B> Service<Request<B>> for VerifiedWebhook<S>
where
S: Service<Request<B>, Response = Response> + Clone + Send + 'static,
S::Future: Send + 'static,
B: Send + 'static,
{
type Response = Response;
type Error = S::Error;
type Future = Pin<Box<dyn Future<Output = Result<Response, Self::Error>> + Send>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.inner.poll_ready(cx)
}
fn call(&mut self, mut request: Request<B>) -> Self::Future {
let spare = self.inner.clone();
let mut ready = std::mem::replace(&mut self.inner, spare);
let layer = self.layer.clone();
Box::pin(async move {
match layer.verifier.require_webhook(request.headers(), &layer.providers).await {
Ok(webhook) => {
request.extensions_mut().insert(VouchedWebhook(webhook));
ready.call(request).await
}
Err(refusal) => Ok(Rejection::from(refusal).into_response()),
}
})
}
}