Struct oxide_auth::frontends::simple::endpoint::Generic

pub struct Generic<R, A, I, S = Vacant, C = Vacant, L = Vacant> {
    pub registrar: R,
    pub authorizer: A,
    pub issuer: I,
    pub solicitor: S,
    pub scopes: C,
    pub response: L,
}

A rather basic Endpoint implementation.

Substitue all parts that are not provided with the marker struct Vacant. This will at least ensure that no security properties are violated. Some flows may be unavailable when some primitives are missing. See AuthorizationFlow, AccessTokenFlow, ResourceFlow for more details.

Included types are assumed to be implemented independently, with no major connections. All attributes are public, so there is no inner invariant.

Usage

You should prefer this implementation when there are special requirements for your Endpoint implementation, or it is created ad-hoc. It also does some static type checking on dedicated methods to ensure that the creation of specific flows succeeds. You should prefer to_authorization, to_access_token, and to_resource over the erroring preparation methods in AuthorizationFlow, AccessTokenFlow, and ResourceFlow respectively.

This should not be used when you special interacting primitives are used, that originate from outside this library. For example if you intend for your Scopes to be dynamically generated from a list of registered clients, its likely cleaner to provide your own Endpoint implementation instead.

Example

Here is an example where a Generic is used to set up an endpoint that is filled with the minimal members to be useable for an AccessTokenFlow.

use oxide_auth::endpoint::{AccessTokenFlow, Endpoint, WebRequest};
use oxide_auth::primitives::{
    authorizer::AuthMap,
    generator::RandomGenerator,
    issuer::TokenMap,
    registrar::ClientMap,
};

fn access_token_endpoint<R: WebRequest>() -> AccessTokenFlow<impl Endpoint<R>, R> 
    where R::Response: Default,
{
    let endpoint = Generic {
        authorizer: AuthMap::new(RandomGenerator::new(16)),
        registrar: ClientMap::new(),
        issuer: TokenMap::new(RandomGenerator::new(16)),
        scopes: Vacant,
        solicitor: Vacant,
        response: Vacant,
    };
    endpoint.to_access_token()
}

Fields

registrar: R

The registrar implementation, or Vacant if it is not necesary.

authorizer: A

The authorizer implementation, or Vacant if it is not necesary.

issuer: I

The issuer implementation, or Vacant if it is not necesary.

solicitor: S

A solicitor implementation fit for the request types, or Vacant if it is not necesary.

scopes: C

Determine scopes for the request types, or Vacant if this does not protect resources.

response: L

Creates responses, or Vacant if Default::default is applicable.

Methods

impl<R, A, I, O, C, L> Generic<R, A, I, O, C, L>

pub fn with_solicitor<N>(self, new_solicitor: N) -> Generic<R, A, I, N, C, L>

Change the used solicitor.

pub fn with_scopes<S>(self, new_scopes: S) -> Generic<R, A, I, O, S, L>

Change the used scopes.

pub fn to_authorization<W: WebRequest>(self) -> AuthorizationFlow<Self, W> where
    Self: Endpoint<W>,
    R: Registrar,
    A: Authorizer, 

Create an authorization flow.

Opposed to AuthorizationFlow::prepare this statically ensures that the construction succeeds.

pub fn to_access_token<W: WebRequest>(self) -> AccessTokenFlow<Self, W> where
    Self: Endpoint<W>,
    R: Registrar,
    A: Authorizer,
    I: Issuer, 

Create an access token flow.

Opposed to AccessTokenFlow::prepare this statically ensures that the construction succeeds.

pub fn to_refresh<W: WebRequest>(self) -> RefreshFlow<Self, W> where
    Self: Endpoint<W>,
    R: Registrar,
    I: Issuer, 

Create a token refresh flow.

Opposed to RefreshFlow::prepare this statically ensures that the construction succeeds.

pub fn to_resource<W: WebRequest>(self) -> ResourceFlow<Self, W> where
    Self: Endpoint<W>,
    I: Issuer, 

Create a resource access flow.

Opposed to ResourceFlow::prepare this statically ensures that the construction succeeds.

pub fn assert<W: WebRequest>(self) -> Self where
    Self: Endpoint<W>, 

Check, statically, that this is an endpoint for some request.

This is mainly a utility method intended for compilation and integration tests.

Trait Implementations

impl<W, R, A, I, O, C, L> Endpoint<W> for Generic<R, A, I, O, C, L> where
    W: WebRequest,
    R: OptRegistrar,
    A: OptAuthorizer,
    I: OptIssuer,
    O: OwnerSolicitor<W>,
    C: Scopes<W>,
    L: ResponseCreator<W>, 

type Error = Error<W>

The error typed used as the error representation of each flow.

fn registrar(&self) -> Option<&dyn Registrar>

A registrar if this endpoint can access one.

fn authorizer_mut(&mut self) -> Option<&mut dyn Authorizer>

An authorizer if this endpoint can access one.

fn issuer_mut(&mut self) -> Option<&mut dyn Issuer>

An issuer if this endpoint can access one.

fn owner_solicitor(&mut self) -> Option<&mut dyn OwnerSolicitor<W>>

Return the system that checks owner consent.

fn scopes(&mut self) -> Option<&mut dyn Scopes<W>>

Determine the required scopes for a request.

fn response(
    &mut self,
    request: &mut W,
    kind: Template
) -> Result<W::Response, Self::Error>

Generate a prototype response.

fn error(&mut self, err: OAuthError) -> Error<W>

Wrap an error.

fn web_error(&mut self, err: W::Error) -> Error<W>

Wrap an error in the request/response types.

fn extension(&mut self) -> Option<&mut dyn Extension>

Get the central extension instance this endpoint.