oxide_auth/frontends/simple/extensions/
mod.rs

1//! Basic extension systems.
2//!
3//! Note that extensions will probably return in `v0.4` but not its preview versions.
4pub use crate::code_grant::authorization::Request as AuthorizationRequest;
5pub use crate::code_grant::accesstoken::Request as AccessTokenRequest;
6pub use crate::code_grant::client_credentials::Request as ClientCredentialsRequest;
7
8mod extended;
9mod pkce;
10mod list;
11
12use std::borrow::{Cow, ToOwned};
13use std::rc::Rc;
14use std::sync::Arc;
15
16pub use self::extended::Extended;
17pub use self::pkce::Pkce;
18pub use self::list::AddonList;
19use crate::primitives::grant::{GrantExtension, Value};
20
21/// Result of extension processing.
22#[must_use = "This type is similar to std::result::Result and should not be ignored."]
23pub enum AddonResult {
24    /// Allow the request unchanged.
25    Ok,
26
27    /// Allow the request and attach additional data to the response.
28    Data(Value),
29
30    /// Do not permit the request.
31    Err,
32}
33
34/// An extension reacting to an initial authorization code request.
35pub trait AuthorizationAddon: GrantExtension {
36    /// Provides data for this request or signals faulty data.
37    ///
38    /// There may be two main types of extensions:
39    /// - Extensions storing additional information about the client
40    /// - Validators asserting additional requirements
41    ///
42    /// Derived information which needs to be bound to the returned grant can be stored in an
43    /// encoded form by returning `Ok(extension_data)` while errors can be signaled via `Err(())`.
44    /// Extensions can also store their pure existance by initializing the extension struct without
45    /// data. Specifically, the data can be used in a corresponding `AccessTokenExtension`.
46    fn execute(&self, request: &dyn AuthorizationRequest) -> AddonResult;
47}
48
49/// An extension reacting to an access token request with a provided access token.
50pub trait AccessTokenAddon: GrantExtension {
51    /// Process an access token request, utilizing the extensions stored data if any.
52    ///
53    /// The semantics are equivalent to that of `CodeExtension` except that any data which was
54    /// returned as a response to the authorization code request is provided as an additional
55    /// parameter.
56    fn execute(&self, request: &dyn AccessTokenRequest, code_data: Option<Value>) -> AddonResult;
57}
58
59/// An extension reacting to a client credentials request..
60pub trait ClientCredentialsAddon: GrantExtension {
61    /// Process a client credentials request, utilizing the extensions stored data if any.
62    fn execute(&self, request: &dyn ClientCredentialsRequest) -> AddonResult;
63}
64
65impl<'a, T: AuthorizationAddon + ?Sized> AuthorizationAddon for &'a T {
66    fn execute(&self, request: &dyn AuthorizationRequest) -> AddonResult {
67        (**self).execute(request)
68    }
69}
70
71impl<'a, T: AuthorizationAddon + ?Sized> AuthorizationAddon for Cow<'a, T>
72where
73    T: Clone + ToOwned,
74{
75    fn execute(&self, request: &dyn AuthorizationRequest) -> AddonResult {
76        self.as_ref().execute(request)
77    }
78}
79
80impl<T: AuthorizationAddon + ?Sized> AuthorizationAddon for Box<T> {
81    fn execute(&self, request: &dyn AuthorizationRequest) -> AddonResult {
82        (**self).execute(request)
83    }
84}
85
86impl<T: AuthorizationAddon + ?Sized> AuthorizationAddon for Arc<T> {
87    fn execute(&self, request: &dyn AuthorizationRequest) -> AddonResult {
88        (**self).execute(request)
89    }
90}
91
92impl<T: AuthorizationAddon + ?Sized> AuthorizationAddon for Rc<T> {
93    fn execute(&self, request: &dyn AuthorizationRequest) -> AddonResult {
94        (**self).execute(request)
95    }
96}
97
98impl<'a, T: AccessTokenAddon + ?Sized> AccessTokenAddon for &'a T {
99    fn execute(&self, request: &dyn AccessTokenRequest, data: Option<Value>) -> AddonResult {
100        (**self).execute(request, data)
101    }
102}
103
104impl<'a, T: AccessTokenAddon + ?Sized> AccessTokenAddon for Cow<'a, T>
105where
106    T: Clone + ToOwned,
107{
108    fn execute(&self, request: &dyn AccessTokenRequest, data: Option<Value>) -> AddonResult {
109        self.as_ref().execute(request, data)
110    }
111}
112
113impl<T: AccessTokenAddon + ?Sized> AccessTokenAddon for Box<T> {
114    fn execute(&self, request: &dyn AccessTokenRequest, data: Option<Value>) -> AddonResult {
115        (**self).execute(request, data)
116    }
117}
118
119impl<T: AccessTokenAddon + ?Sized> AccessTokenAddon for Arc<T> {
120    fn execute(&self, request: &dyn AccessTokenRequest, data: Option<Value>) -> AddonResult {
121        (**self).execute(request, data)
122    }
123}
124
125impl<T: AccessTokenAddon + ?Sized> AccessTokenAddon for Rc<T> {
126    fn execute(&self, request: &dyn AccessTokenRequest, data: Option<Value>) -> AddonResult {
127        (**self).execute(request, data)
128    }
129}
130
131impl<'a, T: ClientCredentialsAddon + ?Sized> ClientCredentialsAddon for &'a T {
132    fn execute(&self, request: &dyn ClientCredentialsRequest) -> AddonResult {
133        (**self).execute(request)
134    }
135}
136
137impl<'a, T: ClientCredentialsAddon + ?Sized> ClientCredentialsAddon for Cow<'a, T>
138where
139    T: Clone + ToOwned,
140{
141    fn execute(&self, request: &dyn ClientCredentialsRequest) -> AddonResult {
142        self.as_ref().execute(request)
143    }
144}
145
146impl<T: ClientCredentialsAddon + ?Sized> ClientCredentialsAddon for Box<T> {
147    fn execute(&self, request: &dyn ClientCredentialsRequest) -> AddonResult {
148        (**self).execute(request)
149    }
150}
151
152impl<T: ClientCredentialsAddon + ?Sized> ClientCredentialsAddon for Arc<T> {
153    fn execute(&self, request: &dyn ClientCredentialsRequest) -> AddonResult {
154        (**self).execute(request)
155    }
156}
157
158impl<T: ClientCredentialsAddon + ?Sized> ClientCredentialsAddon for Rc<T> {
159    fn execute(&self, request: &dyn ClientCredentialsRequest) -> AddonResult {
160        (**self).execute(request)
161    }
162}