oxide_auth/frontends/simple/extensions/
extended.rs

1use crate::endpoint::{Endpoint, Extension, OAuthError, OwnerSolicitor, Scopes, Template, WebRequest};
2use crate::primitives::authorizer::Authorizer;
3use crate::primitives::issuer::Issuer;
4use crate::primitives::registrar::Registrar;
5
6use super::AddonList;
7
8/// An inner endpoint with simple extensions.
9///
10/// If the inner endpoint had any extension, it will simply never be provided to any flow and
11/// overwritten. Therefore, this is mainly useful for other endpoints that did not implement
12/// extensions by themselves such as `frontends::simple::endpoint::Generic`.
13pub struct Extended<Inner, Extension> {
14    /// Endpoint being extended. This field is `pub` for `oxide-auth-async` be able to implement
15    /// async version of some traits.
16    pub inner: Inner,
17
18    /// Extensions of the endpoint. This field is `pub` for `oxide-auth-async` be able to implement
19    /// async version of some traits.
20    pub addons: Extension,
21}
22
23impl<Inner> Extended<Inner, AddonList> {
24    /// Wrap an endpoint with a standard extension system.
25    pub fn new(inner: Inner) -> Self {
26        Extended {
27            inner,
28            addons: AddonList::default(),
29        }
30    }
31}
32
33impl<Inner, E> Extended<Inner, E> {
34    /// Wrap an inner endpoint with a preconstructed extension instance.
35    pub fn extend_with(inner: Inner, extension: E) -> Self {
36        Extended {
37            inner,
38            addons: extension,
39        }
40    }
41
42    /// A reference to the extension.
43    pub fn extension(&self) -> &E {
44        &self.addons
45    }
46
47    /// A mutable reference to the extension.
48    pub fn extension_mut(&mut self) -> &mut E {
49        &mut self.addons
50    }
51}
52
53impl<Request, Inner, Ext> Endpoint<Request> for Extended<Inner, Ext>
54where
55    Request: WebRequest,
56    Inner: Endpoint<Request>,
57    Ext: Extension,
58{
59    type Error = Inner::Error;
60
61    fn registrar(&self) -> Option<&dyn Registrar> {
62        self.inner.registrar()
63    }
64
65    fn authorizer_mut(&mut self) -> Option<&mut dyn Authorizer> {
66        self.inner.authorizer_mut()
67    }
68
69    fn issuer_mut(&mut self) -> Option<&mut dyn Issuer> {
70        self.inner.issuer_mut()
71    }
72
73    fn owner_solicitor(&mut self) -> Option<&mut dyn OwnerSolicitor<Request>> {
74        self.inner.owner_solicitor()
75    }
76
77    fn scopes(&mut self) -> Option<&mut dyn Scopes<Request>> {
78        self.inner.scopes()
79    }
80
81    fn response(
82        &mut self, request: &mut Request, kind: Template,
83    ) -> Result<Request::Response, Self::Error> {
84        self.inner.response(request, kind)
85    }
86
87    fn error(&mut self, err: OAuthError) -> Self::Error {
88        self.inner.error(err)
89    }
90
91    fn web_error(&mut self, err: Request::Error) -> Self::Error {
92        self.inner.web_error(err)
93    }
94
95    fn extension(&mut self) -> Option<&mut dyn Extension> {
96        Some(&mut self.addons)
97    }
98}