Struct MapErr 

pub struct MapErr<R, F> { /* private fields */ }

A wrapper which is used to map the error type of a repository to another

Implementations

impl<R, F> MapErr<R, F>

pub fn new(inner: R, mapper: F) -> Self

Create a new MapErr wrapper from an inner repository and a mapper function

Trait Implementations

impl<R, F, E> AppSessionRepository for MapErr<R, F>

where R: AppSessionRepository, F: FnMut(<R as AppSessionRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn list<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: AppSessionFilter<'life1>, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<AppSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List AppSession with the given filter and pagination

fn count<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: AppSessionFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count the number of AppSession with the given filter

fn finish_sessions_to_replace_device<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, user: &'life2 User, device: &'life3 Device, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Finishes any application sessions that are using the specified device’s ID.

impl<R, F, E> BrowserSessionRepository for MapErr<R, F>

where R: BrowserSessionRepository, F: FnMut(<R as BrowserSessionRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<BrowserSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup a [BrowserSession] by its ID

fn add<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, user: &'life3 User, user_agent: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<BrowserSession, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Create a new [BrowserSession] for a [User]

fn finish<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, user_session: BrowserSession, ) -> Pin<Box<dyn Future<Output = Result<BrowserSession, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Finish a [BrowserSession]

fn finish_bulk<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, filter: BrowserSessionFilter<'life2>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Mark all the [BrowserSession] matching the given filter as finished

fn list<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: BrowserSessionFilter<'life1>, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<BrowserSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List [BrowserSession] with the given filter and pagination

fn count<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: BrowserSessionFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count the number of [BrowserSession] with the given filter

fn authenticate_with_password<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, user_session: &'life3 BrowserSession, user_password: &'life4 Password, ) -> Pin<Box<dyn Future<Output = Result<Authentication, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Authenticate a [BrowserSession] with the given [Password]

fn authenticate_with_upstream<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, user_session: &'life3 BrowserSession, upstream_oauth_session: &'life4 UpstreamOAuthAuthorizationSession, ) -> Pin<Box<dyn Future<Output = Result<Authentication, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Authenticate a [BrowserSession] with the given [UpstreamOAuthAuthorizationSession]

fn get_last_authentication<'life0, 'life1, 'async_trait>( &'life0 mut self, user_session: &'life1 BrowserSession, ) -> Pin<Box<dyn Future<Output = Result<Option<Authentication>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the last successful authentication for a [BrowserSession]

fn record_batch_activity<'life0, 'async_trait>( &'life0 mut self, activity: Vec<(Ulid, DateTime<Utc>, Option<IpAddr>)>, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Record a batch of [BrowserSession] activity

fn cleanup_finished<'life0, 'async_trait>( &'life0 mut self, since: Option<DateTime<Utc>>, until: DateTime<Utc>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<DateTime<Utc>>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup finished [BrowserSession]s

fn cleanup_inactive_ips<'life0, 'async_trait>( &'life0 mut self, since: Option<DateTime<Utc>>, threshold: DateTime<Utc>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<DateTime<Utc>>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clear IP addresses from sessions inactive since the threshold

impl<R, F, E> CompatAccessTokenRepository for MapErr<R, F>

where R: CompatAccessTokenRepository, F: FnMut(<R as CompatAccessTokenRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<CompatAccessToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup a compat access token by its ID

fn find_by_token<'life0, 'life1, 'async_trait>( &'life0 mut self, access_token: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<CompatAccessToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find a compat access token by its token

fn add<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, compat_session: &'life3 CompatSession, token: String, expires_after: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<CompatAccessToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Add a new compat access token to the database

fn expire<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, compat_access_token: CompatAccessToken, ) -> Pin<Box<dyn Future<Output = Result<CompatAccessToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Set the expiration time of the compat access token to now

impl<R, F, E> CompatRefreshTokenRepository for MapErr<R, F>

where R: CompatRefreshTokenRepository, F: FnMut(<R as CompatRefreshTokenRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<CompatRefreshToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup a compat refresh token by its ID

fn find_by_token<'life0, 'life1, 'async_trait>( &'life0 mut self, refresh_token: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<CompatRefreshToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find a compat refresh token by its token

fn add<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, compat_session: &'life3 CompatSession, compat_access_token: &'life4 CompatAccessToken, token: String, ) -> Pin<Box<dyn Future<Output = Result<CompatRefreshToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Add a new compat refresh token to the database

fn consume_and_replace<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, compat_refresh_token: CompatRefreshToken, successor_compat_refresh_token: &'life2 CompatRefreshToken, ) -> Pin<Box<dyn Future<Output = Result<CompatRefreshToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Consume the given compat refresh token, as well as all other refresh tokens from the same session, except for the given successor compat refresh token.

impl<R, F, E> CompatSessionRepository for MapErr<R, F>

where R: CompatSessionRepository, F: FnMut(<R as CompatSessionRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<CompatSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup a compat session by its ID

fn add<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, user: &'life3 User, device: Device, browser_session: Option<&'life4 BrowserSession>, is_synapse_admin: bool, human_name: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<CompatSession, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Start a new compat session

fn finish<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, compat_session: CompatSession, ) -> Pin<Box<dyn Future<Output = Result<CompatSession, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

End a compat session

fn finish_bulk<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, filter: CompatSessionFilter<'life2>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Mark all the [CompatSession] matching the given filter as finished

fn list<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: CompatSessionFilter<'life1>, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<(CompatSession, Option<CompatSsoLogin>)>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List [CompatSession] with the given filter and pagination

fn count<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: CompatSessionFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count the number of [CompatSession] with the given filter

fn record_batch_activity<'life0, 'async_trait>( &'life0 mut self, activity: Vec<(Ulid, DateTime<Utc>, Option<IpAddr>)>, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Record a batch of [CompatSession] activity

fn record_user_agent<'life0, 'async_trait>( &'life0 mut self, compat_session: CompatSession, user_agent: String, ) -> Pin<Box<dyn Future<Output = Result<CompatSession, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Record the user agent of a compat session

fn set_human_name<'life0, 'async_trait>( &'life0 mut self, compat_session: CompatSession, human_name: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<CompatSession, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set the human name of a compat session

fn cleanup_finished<'life0, 'async_trait>( &'life0 mut self, since: Option<DateTime<Utc>>, until: DateTime<Utc>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<DateTime<Utc>>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup finished [CompatSession]s and their associated tokens.

fn cleanup_inactive_ips<'life0, 'async_trait>( &'life0 mut self, since: Option<DateTime<Utc>>, threshold: DateTime<Utc>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<DateTime<Utc>>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clear IP addresses from sessions inactive since the threshold

impl<R, F, E> CompatSsoLoginRepository for MapErr<R, F>

where R: CompatSsoLoginRepository, F: FnMut(<R as CompatSsoLoginRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<CompatSsoLogin>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup a compat SSO login by its ID

fn find_for_session<'life0, 'life1, 'async_trait>( &'life0 mut self, session: &'life1 CompatSession, ) -> Pin<Box<dyn Future<Output = Result<Option<CompatSsoLogin>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find a compat SSO login by its session

fn find_by_token<'life0, 'life1, 'async_trait>( &'life0 mut self, login_token: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<CompatSsoLogin>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find a compat SSO login by its login token

fn add<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, login_token: String, redirect_uri: Url, ) -> Pin<Box<dyn Future<Output = Result<CompatSsoLogin, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Start a new compat SSO login token

fn fulfill<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, compat_sso_login: CompatSsoLogin, browser_session: &'life2 BrowserSession, ) -> Pin<Box<dyn Future<Output = Result<CompatSsoLogin, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fulfill a compat SSO login by providing a browser session

fn exchange<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, compat_sso_login: CompatSsoLogin, compat_session: &'life2 CompatSession, ) -> Pin<Box<dyn Future<Output = Result<CompatSsoLogin, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Mark a compat SSO login as exchanged

fn list<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: CompatSsoLoginFilter<'life1>, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<CompatSsoLogin>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List [CompatSsoLogin] with the given filter and pagination

fn count<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: CompatSsoLoginFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count the number of [CompatSsoLogin] with the given filter

impl<R, F, E> OAuth2AccessTokenRepository for MapErr<R, F>

where R: OAuth2AccessTokenRepository, F: FnMut(<R as OAuth2AccessTokenRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<AccessToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup an access token by its ID

fn find_by_token<'life0, 'life1, 'async_trait>( &'life0 mut self, access_token: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<AccessToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find an access token by its token

fn add<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, session: &'life3 Session, access_token: String, expires_after: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<AccessToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Add a new access token to the database

fn revoke<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, access_token: AccessToken, ) -> Pin<Box<dyn Future<Output = Result<AccessToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Revoke an access token

fn mark_used<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, access_token: AccessToken, ) -> Pin<Box<dyn Future<Output = Result<AccessToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark the access token as used, to track when it was first used

fn cleanup_revoked<'life0, 'async_trait>( &'life0 mut self, since: Option<DateTime<Utc>>, until: DateTime<Utc>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<DateTime<Utc>>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup revoked access tokens

fn cleanup_expired<'life0, 'async_trait>( &'life0 mut self, since: Option<DateTime<Utc>>, until: DateTime<Utc>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<DateTime<Utc>>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup expired access tokens

impl<R, F, E> OAuth2AuthorizationGrantRepository for MapErr<R, F>

where R: OAuth2AuthorizationGrantRepository, F: FnMut(<R as OAuth2AuthorizationGrantRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn add<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, client: &'life3 Client, redirect_uri: Url, scope: Scope, code: Option<AuthorizationCode>, state: Option<String>, nonce: Option<String>, response_mode: ResponseMode, response_type_id_token: bool, login_hint: Option<String>, locale: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<AuthorizationGrant, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Create a new authorization grant

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<AuthorizationGrant>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup an authorization grant by its ID

fn find_by_code<'life0, 'life1, 'async_trait>( &'life0 mut self, code: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<AuthorizationGrant>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find an authorization grant by its code

fn fulfill<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, session: &'life2 Session, authorization_grant: AuthorizationGrant, ) -> Pin<Box<dyn Future<Output = Result<AuthorizationGrant, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fulfill an authorization grant, by giving the [Session] that it created

fn exchange<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, authorization_grant: AuthorizationGrant, ) -> Pin<Box<dyn Future<Output = Result<AuthorizationGrant, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark an authorization grant as exchanged

fn cleanup<'life0, 'async_trait>( &'life0 mut self, since: Option<Ulid>, until: Ulid, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<Ulid>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup old authorization grants

impl<R, F, E> OAuth2ClientRepository for MapErr<R, F>

where R: OAuth2ClientRepository, F: FnMut(<R as OAuth2ClientRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<Client>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup an OAuth client by its ID

fn find_by_metadata_digest<'life0, 'life1, 'async_trait>( &'life0 mut self, digest: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Client>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find an OAuth client by its metadata digest

fn load_batch<'life0, 'async_trait>( &'life0 mut self, ids: BTreeSet<Ulid>, ) -> Pin<Box<dyn Future<Output = Result<BTreeMap<Ulid, Client>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Load a batch of OAuth clients by their IDs

fn add<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, redirect_uris: Vec<Url>, metadata_digest: Option<String>, encrypted_client_secret: Option<String>, application_type: Option<ApplicationType>, grant_types: Vec<GrantType>, client_name: Option<String>, logo_uri: Option<Url>, client_uri: Option<Url>, policy_uri: Option<Url>, tos_uri: Option<Url>, jwks_uri: Option<Url>, jwks: Option<PublicJsonWebKeySet>, id_token_signed_response_alg: Option<JsonWebSignatureAlg>, userinfo_signed_response_alg: Option<JsonWebSignatureAlg>, token_endpoint_auth_method: Option<OAuthClientAuthenticationMethod>, token_endpoint_auth_signing_alg: Option<JsonWebSignatureAlg>, initiate_login_uri: Option<Url>, ) -> Pin<Box<dyn Future<Output = Result<Client, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Add a new OAuth client

fn upsert_static<'life0, 'async_trait>( &'life0 mut self, client_id: Ulid, client_name: Option<String>, client_auth_method: OAuthClientAuthenticationMethod, encrypted_client_secret: Option<String>, jwks: Option<PublicJsonWebKeySet>, jwks_uri: Option<Url>, redirect_uris: Vec<Url>, ) -> Pin<Box<dyn Future<Output = Result<Client, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Add or replace a static client

fn all_static<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Vec<Client>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List all static clients

fn delete<'life0, 'async_trait>( &'life0 mut self, client: Client, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete a client

fn delete_by_id<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete a client by ID

fn find_by_client_id<'life0, 'life1, 'async_trait>( &'life0 mut self, client_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Client>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find an OAuth client by its client ID

impl<R, F, E> OAuth2DeviceCodeGrantRepository for MapErr<R, F>

where R: OAuth2DeviceCodeGrantRepository, F: FnMut(<R as OAuth2DeviceCodeGrantRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn add<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, params: OAuth2DeviceCodeGrantParams<'life3>, ) -> Pin<Box<dyn Future<Output = Result<DeviceCodeGrant, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Create a new device code grant

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<DeviceCodeGrant>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup a device code grant by its ID

fn find_by_device_code<'life0, 'life1, 'async_trait>( &'life0 mut self, device_code: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<DeviceCodeGrant>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Lookup a device code grant by its device code

fn find_by_user_code<'life0, 'life1, 'async_trait>( &'life0 mut self, user_code: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<DeviceCodeGrant>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Lookup a device code grant by its user code

fn fulfill<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, device_code_grant: DeviceCodeGrant, browser_session: &'life2 BrowserSession, ) -> Pin<Box<dyn Future<Output = Result<DeviceCodeGrant, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Mark the device code grant as fulfilled with the given browser session

fn reject<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, device_code_grant: DeviceCodeGrant, browser_session: &'life2 BrowserSession, ) -> Pin<Box<dyn Future<Output = Result<DeviceCodeGrant, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Mark the device code grant as rejected with the given browser session

fn exchange<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, device_code_grant: DeviceCodeGrant, session: &'life2 Session, ) -> Pin<Box<dyn Future<Output = Result<DeviceCodeGrant, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Mark the device code grant as exchanged and store the session which was created

fn cleanup<'life0, 'async_trait>( &'life0 mut self, since: Option<Ulid>, until: Ulid, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<Ulid>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup old device code grants

impl<R, F, E> OAuth2RefreshTokenRepository for MapErr<R, F>

where R: OAuth2RefreshTokenRepository, F: FnMut(<R as OAuth2RefreshTokenRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<RefreshToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup a refresh token by its ID

fn find_by_token<'life0, 'life1, 'async_trait>( &'life0 mut self, refresh_token: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<RefreshToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find a refresh token by its token

fn add<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, session: &'life3 Session, access_token: &'life4 AccessToken, refresh_token: String, ) -> Pin<Box<dyn Future<Output = Result<RefreshToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Add a new refresh token to the database

fn consume<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, refresh_token: RefreshToken, replaced_by: &'life2 RefreshToken, ) -> Pin<Box<dyn Future<Output = Result<RefreshToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Consume a refresh token

fn revoke<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, refresh_token: RefreshToken, ) -> Pin<Box<dyn Future<Output = Result<RefreshToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Revoke a refresh token

fn cleanup_revoked<'life0, 'async_trait>( &'life0 mut self, since: Option<DateTime<Utc>>, until: DateTime<Utc>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<DateTime<Utc>>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup revoked refresh tokens that were revoked before a certain time

fn cleanup_consumed<'life0, 'async_trait>( &'life0 mut self, since: Option<DateTime<Utc>>, until: DateTime<Utc>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<DateTime<Utc>>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup consumed refresh tokens that were consumed before a certain time

impl<R, F, E> OAuth2SessionRepository for MapErr<R, F>

where R: OAuth2SessionRepository, F: FnMut(<R as OAuth2SessionRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<Session>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup an [Session] by its ID

fn add<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, client: &'life3 Client, user: Option<&'life4 User>, user_session: Option<&'life5 BrowserSession>, scope: Scope, ) -> Pin<Box<dyn Future<Output = Result<Session, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Create a new [Session] with the given parameters

fn add_from_browser_session<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, client: &'life3 Client, user_session: &'life4 BrowserSession, scope: Scope, ) -> Pin<Box<dyn Future<Output = Result<Session, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Create a new [Session] out of a [Client] and a [BrowserSession]

fn add_from_client_credentials<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, client: &'life3 Client, scope: Scope, ) -> Pin<Box<dyn Future<Output = Result<Session, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Create a new [Session] for a [Client] using the client credentials flow

fn finish<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, session: Session, ) -> Pin<Box<dyn Future<Output = Result<Session, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark a [Session] as finished

fn finish_bulk<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, filter: OAuth2SessionFilter<'life2>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Mark all the [Session] matching the given filter as finished

fn list<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: OAuth2SessionFilter<'life1>, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<Session>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List [Session]s matching the given filter and pagination parameters

fn count<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: OAuth2SessionFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count [Session]s matching the given filter

fn record_batch_activity<'life0, 'async_trait>( &'life0 mut self, activity: Vec<(Ulid, DateTime<Utc>, Option<IpAddr>)>, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Record a batch of [Session] activity

fn record_user_agent<'life0, 'async_trait>( &'life0 mut self, session: Session, user_agent: String, ) -> Pin<Box<dyn Future<Output = Result<Session, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Record the user agent of a [Session]

fn set_human_name<'life0, 'async_trait>( &'life0 mut self, session: Session, human_name: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<Session, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set the human name of a [Session]

fn cleanup_finished<'life0, 'async_trait>( &'life0 mut self, since: Option<DateTime<Utc>>, until: DateTime<Utc>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<DateTime<Utc>>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup finished [Session]s

fn cleanup_inactive_ips<'life0, 'async_trait>( &'life0 mut self, since: Option<DateTime<Utc>>, threshold: DateTime<Utc>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<DateTime<Utc>>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clear IP addresses from sessions inactive since the threshold

impl<R, F, E> PersonalAccessTokenRepository for MapErr<R, F>

where R: PersonalAccessTokenRepository, F: FnMut(<R as PersonalAccessTokenRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<PersonalAccessToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup an access token by its ID

fn find_by_token<'life0, 'life1, 'async_trait>( &'life0 mut self, access_token: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<PersonalAccessToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find an access token by its token

fn find_active_for_session<'life0, 'life1, 'async_trait>( &'life0 mut self, session: &'life1 PersonalSession, ) -> Pin<Box<dyn Future<Output = Result<Option<PersonalAccessToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find the active access token belonging to a given session.

fn add<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, session: &'life3 PersonalSession, access_token: &'life4 str, expires_after: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<PersonalAccessToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Add a new access token to the database

fn revoke<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, access_token: PersonalAccessToken, ) -> Pin<Box<dyn Future<Output = Result<PersonalAccessToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Revoke an access token

impl<R, F, E> PersonalSessionRepository for MapErr<R, F>

where R: PersonalSessionRepository, F: FnMut(<R as PersonalSessionRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<PersonalSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup a Personal session by its ID

fn add<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, owner: PersonalSessionOwner, actor_user: &'life3 User, human_name: String, scope: Scope, ) -> Pin<Box<dyn Future<Output = Result<PersonalSession, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Start a new Personal session

fn revoke<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, personal_session: PersonalSession, ) -> Pin<Box<dyn Future<Output = Result<PersonalSession, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

End a Personal session

fn revoke_bulk<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, filter: PersonalSessionFilter<'life2>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Revoke all the [PersonalSession]s matching the given filter.

fn list<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: PersonalSessionFilter<'life1>, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<(PersonalSession, Option<PersonalAccessToken>)>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List [PersonalSession]s matching the given filter and pagination parameters

fn count<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: PersonalSessionFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count [PersonalSession]s matching the given filter

fn record_batch_activity<'life0, 'async_trait>( &'life0 mut self, activity: Vec<(Ulid, DateTime<Utc>, Option<IpAddr>)>, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Record a batch of [PersonalSession] activity

impl<R, F, E> PolicyDataRepository for MapErr<R, F>

where R: PolicyDataRepository, F: FnMut(<R as PolicyDataRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn get<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Option<PolicyData>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the latest policy data

fn set<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, data: Value, ) -> Pin<Box<dyn Future<Output = Result<PolicyData, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Set the latest policy data

fn prune<'life0, 'async_trait>( &'life0 mut self, keep: usize, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Prune old policy data

impl<R, F, E> QueueJobRepository for MapErr<R, F>

where R: QueueJobRepository, F: FnMut(<R as QueueJobRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository.

fn schedule<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, queue_name: &'life3 str, payload: Value, metadata: Value, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Schedule a job to be executed as soon as possible by a worker.

fn schedule_later<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, queue_name: &'life3 str, payload: Value, metadata: Value, scheduled_at: DateTime<Utc>, schedule_name: Option<&'life4 str>, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Schedule a job to be executed at a later date by a worker.

fn reserve<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, worker: &'life2 Worker, queues: &'life3 [&'life4 str], count: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<Job>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Reserve multiple jobs from multiple queues

fn mark_as_completed<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark a job as completed

fn mark_as_failed<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, id: Ulid, reason: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Marks a job as failed.

fn retry<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, id: Ulid, delay: Duration, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Retry a job.

fn schedule_available_jobs<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark all scheduled jobs past their scheduled date as available to be executed.

fn cleanup<'life0, 'async_trait>( &'life0 mut self, since: Option<Ulid>, until: Ulid, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<Ulid>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup old completed and failed jobs

impl<R, F, E> QueueScheduleRepository for MapErr<R, F>

where R: QueueScheduleRepository, F: FnMut(<R as QueueScheduleRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository.

fn setup<'life0, 'life1, 'async_trait>( &'life0 mut self, schedules: &'life1 [&'static str], ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Setup the list of schedules in the repository

fn list<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Vec<ScheduleStatus>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List the schedules in the repository, with the last time they were run

impl<R, F, E> QueueWorkerRepository for MapErr<R, F>

where R: QueueWorkerRepository, F: FnMut(<R as QueueWorkerRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository.

fn register<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, ) -> Pin<Box<dyn Future<Output = Result<Worker, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Register a new worker.

fn heartbeat<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, worker: &'life2 Worker, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Send a heartbeat for the given worker.

fn shutdown<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, worker: &'life2 Worker, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Mark the given worker as shutdown.

fn shutdown_dead_workers<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, threshold: Duration, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find dead workers and shut them down.

fn remove_leader_lease_if_expired<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove the leader lease if it is expired, sending a notification to trigger a new leader election.

fn try_get_leader_lease<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, worker: &'life2 Worker, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Try to get the leader lease, renewing it if we already have it

impl<R, F, E> RepositoryAccess for MapErr<R, F>

where R: RepositoryAccess, R::Error: 'static, F: FnMut(R::Error) -> E + Send + Sync + 'static, E: Error + Send + Sync + 'static,

type Error = E

The backend-specific error type used by each repository.

fn upstream_oauth_link<'c>( &'c mut self, ) -> Box<dyn UpstreamOAuthLinkRepository<Error = Self::Error> + 'c>

Get an UpstreamOAuthLinkRepository

fn upstream_oauth_provider<'c>( &'c mut self, ) -> Box<dyn UpstreamOAuthProviderRepository<Error = Self::Error> + 'c>

Get an UpstreamOAuthProviderRepository

fn upstream_oauth_session<'c>( &'c mut self, ) -> Box<dyn UpstreamOAuthSessionRepository<Error = Self::Error> + 'c>

Get an UpstreamOAuthSessionRepository

fn user<'c>(&'c mut self) -> Box<dyn UserRepository<Error = Self::Error> + 'c>

Get an UserRepository

fn user_email<'c>( &'c mut self, ) -> Box<dyn UserEmailRepository<Error = Self::Error> + 'c>

Get an UserEmailRepository

fn user_password<'c>( &'c mut self, ) -> Box<dyn UserPasswordRepository<Error = Self::Error> + 'c>

Get an UserPasswordRepository

fn user_recovery<'c>( &'c mut self, ) -> Box<dyn UserRecoveryRepository<Error = Self::Error> + 'c>

Get an UserRecoveryRepository

fn user_registration<'c>( &'c mut self, ) -> Box<dyn UserRegistrationRepository<Error = Self::Error> + 'c>

Get an UserRegistrationRepository

fn user_registration_token<'c>( &'c mut self, ) -> Box<dyn UserRegistrationTokenRepository<Error = Self::Error> + 'c>

Get an UserRegistrationTokenRepository

fn user_terms<'c>( &'c mut self, ) -> Box<dyn UserTermsRepository<Error = Self::Error> + 'c>

Get an UserTermsRepository

fn browser_session<'c>( &'c mut self, ) -> Box<dyn BrowserSessionRepository<Error = Self::Error> + 'c>

Get a BrowserSessionRepository

fn app_session<'c>( &'c mut self, ) -> Box<dyn AppSessionRepository<Error = Self::Error> + 'c>

Get a AppSessionRepository

fn oauth2_client<'c>( &'c mut self, ) -> Box<dyn OAuth2ClientRepository<Error = Self::Error> + 'c>

Get an OAuth2ClientRepository

fn oauth2_authorization_grant<'c>( &'c mut self, ) -> Box<dyn OAuth2AuthorizationGrantRepository<Error = Self::Error> + 'c>

Get an OAuth2AuthorizationGrantRepository

fn oauth2_session<'c>( &'c mut self, ) -> Box<dyn OAuth2SessionRepository<Error = Self::Error> + 'c>

Get an OAuth2SessionRepository

fn oauth2_access_token<'c>( &'c mut self, ) -> Box<dyn OAuth2AccessTokenRepository<Error = Self::Error> + 'c>

Get an OAuth2AccessTokenRepository

fn oauth2_refresh_token<'c>( &'c mut self, ) -> Box<dyn OAuth2RefreshTokenRepository<Error = Self::Error> + 'c>

Get an OAuth2RefreshTokenRepository

fn oauth2_device_code_grant<'c>( &'c mut self, ) -> Box<dyn OAuth2DeviceCodeGrantRepository<Error = Self::Error> + 'c>

Get an OAuth2DeviceCodeGrantRepository

fn compat_session<'c>( &'c mut self, ) -> Box<dyn CompatSessionRepository<Error = Self::Error> + 'c>

Get a CompatSessionRepository

fn compat_sso_login<'c>( &'c mut self, ) -> Box<dyn CompatSsoLoginRepository<Error = Self::Error> + 'c>

Get a CompatSsoLoginRepository

fn compat_access_token<'c>( &'c mut self, ) -> Box<dyn CompatAccessTokenRepository<Error = Self::Error> + 'c>

Get a CompatAccessTokenRepository

fn compat_refresh_token<'c>( &'c mut self, ) -> Box<dyn CompatRefreshTokenRepository<Error = Self::Error> + 'c>

Get a CompatRefreshTokenRepository

fn personal_access_token<'c>( &'c mut self, ) -> Box<dyn PersonalAccessTokenRepository<Error = Self::Error> + 'c>

Get a PersonalAccessTokenRepository

fn personal_session<'c>( &'c mut self, ) -> Box<dyn PersonalSessionRepository<Error = Self::Error> + 'c>

Get a PersonalSessionRepository

fn queue_worker<'c>( &'c mut self, ) -> Box<dyn QueueWorkerRepository<Error = Self::Error> + 'c>

Get a QueueWorkerRepository

fn queue_job<'c>( &'c mut self, ) -> Box<dyn QueueJobRepository<Error = Self::Error> + 'c>

Get a QueueJobRepository

fn queue_schedule<'c>( &'c mut self, ) -> Box<dyn QueueScheduleRepository<Error = Self::Error> + 'c>

Get a QueueScheduleRepository

fn policy_data<'c>( &'c mut self, ) -> Box<dyn PolicyDataRepository<Error = Self::Error> + 'c>

Get a PolicyDataRepository

impl<R, F, E> RepositoryTransaction for MapErr<R, F>

where R: RepositoryTransaction, R::Error: 'static, F: FnMut(R::Error) -> E + Send + Sync + 'static, E: Error,

type Error = E

The error type used by the Self::save and Self::cancel functions

fn save(self: Box<Self>) -> BoxFuture<'static, Result<(), Self::Error>>

Commit the transaction

fn cancel(self: Box<Self>) -> BoxFuture<'static, Result<(), Self::Error>>

Rollback the transaction

impl<R, F, E> UpstreamOAuthLinkRepository for MapErr<R, F>

where R: UpstreamOAuthLinkRepository, F: FnMut(<R as UpstreamOAuthLinkRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<UpstreamOAuthLink>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup an upstream OAuth link by its ID

fn find_by_subject<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, upstream_oauth_provider: &'life1 UpstreamOAuthProvider, subject: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<UpstreamOAuthLink>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Find an upstream OAuth link for a provider by its subject

fn add<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, upstream_oauth_provider: &'life3 UpstreamOAuthProvider, subject: String, human_account_name: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<UpstreamOAuthLink, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Add a new upstream OAuth link

fn associate_to_user<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, upstream_oauth_link: &'life1 UpstreamOAuthLink, user: &'life2 User, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Associate an upstream OAuth link to a user

fn list<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UpstreamOAuthLinkFilter<'life1>, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<UpstreamOAuthLink>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List [UpstreamOAuthLink] with the given filter and pagination

fn count<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UpstreamOAuthLinkFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count the number of [UpstreamOAuthLink] with the given filter

fn remove<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, upstream_oauth_link: UpstreamOAuthLink, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a [UpstreamOAuthLink]

fn cleanup_orphaned<'life0, 'async_trait>( &'life0 mut self, since: Option<Ulid>, until: Ulid, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<Ulid>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup orphaned upstream OAuth links

impl<R, F, E> UpstreamOAuthProviderRepository for MapErr<R, F>

where R: UpstreamOAuthProviderRepository, F: FnMut(<R as UpstreamOAuthProviderRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<UpstreamOAuthProvider>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup an upstream OAuth provider by its ID

fn add<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, params: UpstreamOAuthProviderParams, ) -> Pin<Box<dyn Future<Output = Result<UpstreamOAuthProvider, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Add a new upstream OAuth provider

fn upsert<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, id: Ulid, params: UpstreamOAuthProviderParams, ) -> Pin<Box<dyn Future<Output = Result<UpstreamOAuthProvider, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert or update an upstream OAuth provider

fn delete<'life0, 'async_trait>( &'life0 mut self, provider: UpstreamOAuthProvider, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete an upstream OAuth provider

fn delete_by_id<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete an upstream OAuth provider by its ID

fn disable<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, provider: UpstreamOAuthProvider, ) -> Pin<Box<dyn Future<Output = Result<UpstreamOAuthProvider, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Disable an upstream OAuth provider

fn list<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UpstreamOAuthProviderFilter<'life1>, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<UpstreamOAuthProvider>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List [UpstreamOAuthProvider] with the given filter and pagination

fn count<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UpstreamOAuthProviderFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count the number of [UpstreamOAuthProvider] with the given filter

fn all_enabled<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Vec<UpstreamOAuthProvider>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get all enabled upstream OAuth providers

impl<R, F, E> UpstreamOAuthSessionRepository for MapErr<R, F>

where R: UpstreamOAuthSessionRepository, F: FnMut(<R as UpstreamOAuthSessionRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<UpstreamOAuthAuthorizationSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup a session by its ID

fn add<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, upstream_oauth_provider: &'life3 UpstreamOAuthProvider, state: String, code_challenge_verifier: Option<String>, nonce: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<UpstreamOAuthAuthorizationSession, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Add a session to the database

fn complete_with_link<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, upstream_oauth_authorization_session: UpstreamOAuthAuthorizationSession, upstream_oauth_link: &'life2 UpstreamOAuthLink, id_token: Option<String>, id_token_claims: Option<Value>, extra_callback_parameters: Option<Value>, userinfo: Option<Value>, ) -> Pin<Box<dyn Future<Output = Result<UpstreamOAuthAuthorizationSession, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Mark a session as completed and associate the given link

fn consume<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, upstream_oauth_authorization_session: UpstreamOAuthAuthorizationSession, browser_session: &'life2 BrowserSession, ) -> Pin<Box<dyn Future<Output = Result<UpstreamOAuthAuthorizationSession, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Mark a session as consumed

fn list<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UpstreamOAuthSessionFilter<'life1>, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<UpstreamOAuthAuthorizationSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List [UpstreamOAuthAuthorizationSession] with the given filter and pagination

fn count<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UpstreamOAuthSessionFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count the number of [UpstreamOAuthAuthorizationSession] with the given filter

fn cleanup_orphaned<'life0, 'async_trait>( &'life0 mut self, since: Option<Ulid>, until: Ulid, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<Ulid>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup old authorization sessions that are not linked to a user session

impl<R, F, E> UserEmailRepository for MapErr<R, F>

where R: UserEmailRepository, F: FnMut(<R as UserEmailRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<UserEmail>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup an [UserEmail] by its ID

fn find<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, user: &'life1 User, email: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<UserEmail>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Lookup an [UserEmail] by its email address for a [User]

fn find_by_email<'life0, 'life1, 'async_trait>( &'life0 mut self, email: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<UserEmail>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Lookup an [UserEmail] by its email address

fn all<'life0, 'life1, 'async_trait>( &'life0 mut self, user: &'life1 User, ) -> Pin<Box<dyn Future<Output = Result<Vec<UserEmail>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all [UserEmail] of a [User]

fn list<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UserEmailFilter<'life1>, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<UserEmail>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List [UserEmail] with the given filter and pagination

fn count<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UserEmailFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count the [UserEmail] with the given filter

fn add<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, user: &'life3 User, email: String, ) -> Pin<Box<dyn Future<Output = Result<UserEmail, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Create a new [UserEmail] for a [User]

fn remove<'life0, 'async_trait>( &'life0 mut self, user_email: UserEmail, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete a [UserEmail]

fn remove_bulk<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UserEmailFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete all [UserEmail] with the given filter

fn add_authentication_for_session<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, email: String, session: &'life3 BrowserSession, ) -> Pin<Box<dyn Future<Output = Result<UserEmailAuthentication, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Add a new [UserEmailAuthentication] for a [BrowserSession]

fn add_authentication_for_registration<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, email: String, registration: &'life3 UserRegistration, ) -> Pin<Box<dyn Future<Output = Result<UserEmailAuthentication, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Add a new [UserEmailAuthentication] for a [UserRegistration]

fn add_authentication_code<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, duration: Duration, authentication: &'life3 UserEmailAuthentication, code: String, ) -> Pin<Box<dyn Future<Output = Result<UserEmailAuthenticationCode, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Add a new [UserEmailAuthenticationCode] for a [UserEmailAuthentication]

fn lookup_authentication<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<UserEmailAuthentication>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup a [UserEmailAuthentication]

fn find_authentication_code<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, authentication: &'life1 UserEmailAuthentication, code: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<UserEmailAuthenticationCode>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Find a [UserEmailAuthenticationCode] by its code and session

fn complete_authentication_with_code<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, authentication: UserEmailAuthentication, code: &'life2 UserEmailAuthenticationCode, ) -> Pin<Box<dyn Future<Output = Result<UserEmailAuthentication, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Complete a [UserEmailAuthentication] by using the given code

fn complete_authentication_with_upstream<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, authentication: UserEmailAuthentication, upstream_oauth_authorization_session: &'life2 UpstreamOAuthAuthorizationSession, ) -> Pin<Box<dyn Future<Output = Result<UserEmailAuthentication, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Complete a [UserEmailAuthentication] by using the given upstream oauth authorization session

fn cleanup_authentications<'life0, 'async_trait>( &'life0 mut self, since: Option<Ulid>, until: Ulid, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<Ulid>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup old email authentications

impl<R, F, E> UserPasswordRepository for MapErr<R, F>

where R: UserPasswordRepository, F: FnMut(<R as UserPasswordRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn active<'life0, 'life1, 'async_trait>( &'life0 mut self, user: &'life1 User, ) -> Pin<Box<dyn Future<Output = Result<Option<Password>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the active password for a user

fn add<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, user: &'life3 User, version: u16, hashed_password: String, upgraded_from: Option<&'life4 Password>, ) -> Pin<Box<dyn Future<Output = Result<Password, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Set a new password for a user

impl<R, F, E> UserRecoveryRepository for MapErr<R, F>

where R: UserRecoveryRepository, F: FnMut(<R as UserRecoveryRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup_session<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<UserRecoverySession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup an [UserRecoverySession] by its ID

fn add_session<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, email: String, user_agent: String, ip_address: Option<IpAddr>, locale: String, ) -> Pin<Box<dyn Future<Output = Result<UserRecoverySession, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a new [UserRecoverySession] for the given email

fn find_ticket<'life0, 'life1, 'async_trait>( &'life0 mut self, ticket: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<UserRecoveryTicket>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find a [UserRecoveryTicket] by its ticket

fn add_ticket<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, user_recovery_session: &'life3 UserRecoverySession, user_email: &'life4 UserEmail, ticket: String, ) -> Pin<Box<dyn Future<Output = Result<UserRecoveryTicket, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Add a [UserRecoveryTicket] to the given [UserRecoverySession] for the given [UserEmail]

fn consume_ticket<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, user_recovery_ticket: UserRecoveryTicket, user_recovery_session: UserRecoverySession, ) -> Pin<Box<dyn Future<Output = Result<UserRecoverySession, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Consume a [UserRecoveryTicket] and mark the session as used

fn cleanup<'life0, 'async_trait>( &'life0 mut self, since: Option<Ulid>, until: Ulid, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<Ulid>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup old recovery sessions

impl<R, F, E> UserRegistrationRepository for MapErr<R, F>

where R: UserRegistrationRepository, F: FnMut(<R as UserRegistrationRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<UserRegistration>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup a [UserRegistration] by its ID

fn add<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, username: String, ip_address: Option<IpAddr>, user_agent: Option<String>, post_auth_action: Option<Value>, ) -> Pin<Box<dyn Future<Output = Result<UserRegistration, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a new [UserRegistration] session

fn set_display_name<'life0, 'async_trait>( &'life0 mut self, user_registration: UserRegistration, display_name: String, ) -> Pin<Box<dyn Future<Output = Result<UserRegistration, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set the display name of a [UserRegistration]

fn set_terms_url<'life0, 'async_trait>( &'life0 mut self, user_registration: UserRegistration, terms_url: Url, ) -> Pin<Box<dyn Future<Output = Result<UserRegistration, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set the terms URL of a [UserRegistration]

fn set_email_authentication<'life0, 'life1, 'async_trait>( &'life0 mut self, user_registration: UserRegistration, email_authentication: &'life1 UserEmailAuthentication, ) -> Pin<Box<dyn Future<Output = Result<UserRegistration, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Set the email authentication code of a [UserRegistration]

fn set_password<'life0, 'async_trait>( &'life0 mut self, user_registration: UserRegistration, hashed_password: String, version: u16, ) -> Pin<Box<dyn Future<Output = Result<UserRegistration, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set the password of a [UserRegistration]

fn set_registration_token<'life0, 'life1, 'async_trait>( &'life0 mut self, user_registration: UserRegistration, user_registration_token: &'life1 UserRegistrationToken, ) -> Pin<Box<dyn Future<Output = Result<UserRegistration, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Set the registration token of a [UserRegistration]

fn set_upstream_oauth_authorization_session<'life0, 'life1, 'async_trait>( &'life0 mut self, user_registration: UserRegistration, upstream_oauth_authorization_session: &'life1 UpstreamOAuthAuthorizationSession, ) -> Pin<Box<dyn Future<Output = Result<UserRegistration, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Set an [UpstreamOAuthAuthorizationSession] to associate with a [UserRegistration]

fn complete<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, user_registration: UserRegistration, ) -> Pin<Box<dyn Future<Output = Result<UserRegistration, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Complete a [UserRegistration]

fn cleanup<'life0, 'async_trait>( &'life0 mut self, since: Option<Ulid>, until: Ulid, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<Ulid>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleanup [UserRegistration]s between the given IDs.

impl<R, F, E> UserRegistrationTokenRepository for MapErr<R, F>

where R: UserRegistrationTokenRepository, F: FnMut(<R as UserRegistrationTokenRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<UserRegistrationToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup a [UserRegistrationToken] by its ID

fn find_by_token<'life0, 'life1, 'async_trait>( &'life0 mut self, token: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<UserRegistrationToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Lookup a [UserRegistrationToken] by its token string

fn add<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, token: String, usage_limit: Option<u32>, expires_at: Option<DateTime<Utc>>, ) -> Pin<Box<dyn Future<Output = Result<UserRegistrationToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a new [UserRegistrationToken]

fn use_token<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, token: UserRegistrationToken, ) -> Pin<Box<dyn Future<Output = Result<UserRegistrationToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Increment the usage count of a [UserRegistrationToken]

fn revoke<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, token: UserRegistrationToken, ) -> Pin<Box<dyn Future<Output = Result<UserRegistrationToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Revoke a [UserRegistrationToken]

fn unrevoke<'life0, 'async_trait>( &'life0 mut self, token: UserRegistrationToken, ) -> Pin<Box<dyn Future<Output = Result<UserRegistrationToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Unrevoke a previously revoked [UserRegistrationToken]

fn set_expiry<'life0, 'async_trait>( &'life0 mut self, token: UserRegistrationToken, expires_at: Option<DateTime<Utc>>, ) -> Pin<Box<dyn Future<Output = Result<UserRegistrationToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set the expiration time of a [UserRegistrationToken]

fn set_usage_limit<'life0, 'async_trait>( &'life0 mut self, token: UserRegistrationToken, usage_limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<UserRegistrationToken, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set the usage limit of a [UserRegistrationToken]

fn list<'life0, 'async_trait>( &'life0 mut self, filter: UserRegistrationTokenFilter, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<UserRegistrationToken>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List [UserRegistrationToken]s based on the provided filter

fn count<'life0, 'async_trait>( &'life0 mut self, filter: UserRegistrationTokenFilter, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Count [UserRegistrationToken]s based on the provided filter

impl<R, F, E> UserRepository for MapErr<R, F>

where R: UserRepository, F: FnMut(<R as UserRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<User>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lookup a [User] by its ID

fn find_by_username<'life0, 'life1, 'async_trait>( &'life0 mut self, username: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<User>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find a [User] by its username, in a case-insensitive manner

fn add<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, username: String, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a new [User]

fn exists<'life0, 'life1, 'async_trait>( &'life0 mut self, username: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check if a [User] exists

fn lock<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, user: User, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Lock a [User]

fn unlock<'life0, 'async_trait>( &'life0 mut self, user: User, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Unlock a [User]

fn deactivate<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, user: User, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Deactivate a [User]

fn reactivate<'life0, 'async_trait>( &'life0 mut self, user: User, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Reactivate a [User]

fn delete_unsupported_threepids<'life0, 'life1, 'async_trait>( &'life0 mut self, user: &'life1 User, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete all the unsupported third-party IDs of a [User].

fn set_can_request_admin<'life0, 'async_trait>( &'life0 mut self, user: User, can_request_admin: bool, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set whether a [User] can request admin

fn list<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UserFilter<'life1>, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<User>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List [User] with the given filter and pagination

fn count<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UserFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count the [User] with the given filter

fn acquire_lock_for_sync<'life0, 'life1, 'async_trait>( &'life0 mut self, user: &'life1 User, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Acquire a lock on the user to make sure device operations are done in a sequential way. The lock is released when the repository is saved or rolled back.

impl<R, F, E> UserTermsRepository for MapErr<R, F>

where R: UserTermsRepository, F: FnMut(<R as UserTermsRepository>::Error) -> E + Send + Sync,

type Error = E

The error type returned by the repository

fn accept_terms<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, user: &'life3 User, terms_url: Url, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Accept the terms of service by a [User]

impl<R, F, E1, E2> Repository<E2> for MapErr<R, F>

where R: Repository<E1> + RepositoryAccess<Error = E1> + RepositoryTransaction<Error = E1>, F: FnMut(E1) -> E2 + Send + Sync + 'static, E1: Error + Send + Sync + 'static, E2: Error + Send + Sync + 'static,