snowfinch 0.2.1

Authentication and sessions for Rust tower/axum servers.
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Type-erased session store support.

use std::{pin::Pin, sync::Arc};

use crate::User;

use super::{CreateSessionError, Session, Store};

/// Type-erased [`Store`] used by authentication middleware.
pub struct ErasedStore<User>(Arc<dyn DynStore<User = User>>);

impl<User> ErasedStore<User> {
    /// Wraps a concrete store in a type-erased handle.
    #[inline]
    pub fn new<S>(store: S) -> Self
    where
        S: Store<User = User> + 'static,
    {
        Self(Arc::new(store))
    }
}

impl<User> Clone for ErasedStore<User> {
    #[inline]
    fn clone(&self) -> Self {
        Self(Arc::clone(&self.0))
    }
}

impl<User> Store for ErasedStore<User>
where
    User: crate::User,
{
    type Error = BoxError;

    type User = User;

    type Get = BoxFuture<Result<Option<Session<User::Id>>, BoxError>>;

    type Create = BoxFuture<Result<(), CreateSessionError<BoxError>>>;

    type Revoke = BoxFuture<Result<(), BoxError>>;

    #[inline]
    fn get(&self, id: u128) -> Self::Get {
        self.0.get(id)
    }

    #[inline]
    fn create(&self, session: Session<User::Id>) -> Self::Create {
        self.0.create(session)
    }

    #[inline]
    fn revoke(&self, session: Session<User::Id>) -> Self::Revoke {
        self.0.revoke(session)
    }
}

type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;

type BoxError = Box<dyn std::error::Error + Send + Sync + 'static>;

trait DynStore: Send + Sync + 'static {
    type User: User;

    #[allow(clippy::type_complexity)]
    fn get(
        &self,
        id: u128,
    ) -> BoxFuture<Result<Option<Session<<Self::User as User>::Id>>, BoxError>>;

    fn create(
        &self,
        session: Session<<Self::User as User>::Id>,
    ) -> BoxFuture<Result<(), CreateSessionError<BoxError>>>;

    fn revoke(&self, session: Session<<Self::User as User>::Id>)
    -> BoxFuture<Result<(), BoxError>>;
}

impl<T> DynStore for T
where
    T: Store,
{
    type User = T::User;

    #[inline]
    fn get(
        &self,
        id: u128,
    ) -> BoxFuture<Result<Option<Session<<Self::User as User>::Id>>, BoxError>> {
        let fut = self.get(id);
        Box::pin(async move { fut.await.map_err(Into::into) })
    }

    #[inline]
    fn create(
        &self,
        session: Session<<Self::User as User>::Id>,
    ) -> BoxFuture<Result<(), CreateSessionError<BoxError>>> {
        let fut = self.create(session);

        Box::pin(async move {
            match fut.await {
                Ok(x) => Ok(x),
                Err(CreateSessionError::AlreadyExists) => Err(CreateSessionError::AlreadyExists),
                Err(CreateSessionError::Other(err)) => Err(CreateSessionError::Other(err.into())),
            }
        })
    }

    #[inline]
    fn revoke(
        &self,
        session: Session<<Self::User as User>::Id>,
    ) -> BoxFuture<Result<(), BoxError>> {
        let fut = self.revoke(session);
        Box::pin(async move { fut.await.map_err(Into::into) })
    }
}