Struct MemoryDatabaseAdapter 

pub struct MemoryDatabaseAdapter<U = User, S = Session, A = Account, O = Organization, M = Member, I = Invitation, V = Verification, P = Passkey> { /* private fields */ }

In-memory database adapter for testing and development.

Generic over entity types — use default type parameters for the built-in types, or supply your own custom structs that implement the Memory* traits.

// Using built-in types (no turbofish needed):
let adapter = MemoryDatabaseAdapter::new();

// Using custom types:
let adapter = MemoryDatabaseAdapter::<MyUser, MySession, MyAccount,
    MyOrg, MyMember, MyInvitation, MyVerification>::new();

Implementations

impl MemoryDatabaseAdapter

Constructor for the default (built-in) entity types. Use Default::default() for custom type parameterizations.

pub fn new() -> MemoryDatabaseAdapter

Trait Implementations

impl<U, S, A, O, M, I, V, P> AccountOps for MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>

where U: MemoryUser, S: MemorySession, A: MemoryAccount, O: MemoryOrganization, M: MemoryMember, I: MemoryInvitation, V: MemoryVerification, P: MemoryPasskey,

type Account = A

fn create_account<'life0, 'async_trait>( &'life0 self, create_account: CreateAccount, ) -> Pin<Box<dyn Future<Output = Result<A, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_account<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, provider: &'life1 str, provider_account_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<A>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_user_accounts<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<A>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn update_account<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, update: UpdateAccount, ) -> Pin<Box<dyn Future<Output = Result<A, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn delete_account<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

impl<U, S, A, O, M, I, V, P> ApiKeyOps for MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>

where U: MemoryUser, S: MemorySession, A: MemoryAccount, O: MemoryOrganization, M: MemoryMember, I: MemoryInvitation, V: MemoryVerification, P: MemoryPasskey,

type ApiKey = ApiKey

fn create_api_key<'life0, 'async_trait>( &'life0 self, input: CreateApiKey, ) -> Pin<Box<dyn Future<Output = Result<ApiKey, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_api_key_by_id<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<ApiKey>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_api_key_by_hash<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<ApiKey>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn list_api_keys_by_user<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ApiKey>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn update_api_key<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, update: UpdateApiKey, ) -> Pin<Box<dyn Future<Output = Result<ApiKey, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn delete_api_key<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn delete_expired_api_keys<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<usize, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

Delete all API keys whose expires_at is in the past. Returns the count of deleted keys.

impl<U, S, A, O, M, I, V, P> Default for MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>

fn default() -> MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>

Returns the “default value” for a type.

impl<U, S, A, O, M, I, V, P> InvitationOps for MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>

where U: MemoryUser, S: MemorySession, A: MemoryAccount, O: MemoryOrganization, M: MemoryMember, I: MemoryInvitation, V: MemoryVerification, P: MemoryPasskey,

type Invitation = I

fn create_invitation<'life0, 'async_trait>( &'life0 self, create_inv: CreateInvitation, ) -> Pin<Box<dyn Future<Output = Result<I, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_invitation_by_id<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<I>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_pending_invitation<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, organization_id: &'life1 str, email: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<I>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn update_invitation_status<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, status: InvitationStatus, ) -> Pin<Box<dyn Future<Output = Result<I, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn list_organization_invitations<'life0, 'life1, 'async_trait>( &'life0 self, organization_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<I>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn list_user_invitations<'life0, 'life1, 'async_trait>( &'life0 self, email: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<I>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

impl<U, S, A, O, M, I, V, P> MemberOps for MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>

where U: MemoryUser, S: MemorySession, A: MemoryAccount, O: MemoryOrganization, M: MemoryMember, I: MemoryInvitation, V: MemoryVerification, P: MemoryPasskey,

type Member = M

fn create_member<'life0, 'async_trait>( &'life0 self, create_member: CreateMember, ) -> Pin<Box<dyn Future<Output = Result<M, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_member<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, organization_id: &'life1 str, user_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<M>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_member_by_id<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<M>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn update_member_role<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, member_id: &'life1 str, role: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<M, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn delete_member<'life0, 'life1, 'async_trait>( &'life0 self, member_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn list_organization_members<'life0, 'life1, 'async_trait>( &'life0 self, organization_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<M>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn count_organization_members<'life0, 'life1, 'async_trait>( &'life0 self, organization_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<usize, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn count_organization_owners<'life0, 'life1, 'async_trait>( &'life0 self, organization_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<usize, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

impl<U, S, A, O, M, I, V, P> OrganizationOps for MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>

where U: MemoryUser, S: MemorySession, A: MemoryAccount, O: MemoryOrganization, M: MemoryMember, I: MemoryInvitation, V: MemoryVerification, P: MemoryPasskey,

type Organization = O

fn create_organization<'life0, 'async_trait>( &'life0 self, create_org: CreateOrganization, ) -> Pin<Box<dyn Future<Output = Result<O, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_organization_by_id<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<O>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_organization_by_slug<'life0, 'life1, 'async_trait>( &'life0 self, slug: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<O>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn update_organization<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, update: UpdateOrganization, ) -> Pin<Box<dyn Future<Output = Result<O, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn delete_organization<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn list_user_organizations<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<O>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

impl<U, S, A, O, M, I, V, P> PasskeyOps for MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>

where U: MemoryUser, S: MemorySession, A: MemoryAccount, O: MemoryOrganization, M: MemoryMember, I: MemoryInvitation, V: MemoryVerification, P: MemoryPasskey,

type Passkey = P

fn create_passkey<'life0, 'async_trait>( &'life0 self, input: CreatePasskey, ) -> Pin<Box<dyn Future<Output = Result<P, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_passkey_by_id<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<P>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_passkey_by_credential_id<'life0, 'life1, 'async_trait>( &'life0 self, credential_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<P>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn list_passkeys_by_user<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<P>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn update_passkey_counter<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, counter: u64, ) -> Pin<Box<dyn Future<Output = Result<P, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn update_passkey_name<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, name: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<P, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn delete_passkey<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

impl<U, S, A, O, M, I, V, P> SessionOps for MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>

where U: MemoryUser, S: MemorySession, A: MemoryAccount, O: MemoryOrganization, M: MemoryMember, I: MemoryInvitation, V: MemoryVerification, P: MemoryPasskey,

type Session = S

fn create_session<'life0, 'async_trait>( &'life0 self, create_session: CreateSession, ) -> Pin<Box<dyn Future<Output = Result<S, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_session<'life0, 'life1, 'async_trait>( &'life0 self, token: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<S>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_user_sessions<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<S>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn update_session_expiry<'life0, 'life1, 'async_trait>( &'life0 self, token: &'life1 str, expires_at: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<(), AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn delete_session<'life0, 'life1, 'async_trait>( &'life0 self, token: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn delete_user_sessions<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn delete_expired_sessions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<usize, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn update_session_active_organization<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, token: &'life1 str, organization_id: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<S, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

impl<U, S, A, O, M, I, V, P> TwoFactorOps for MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>

where U: MemoryUser, S: MemorySession, A: MemoryAccount, O: MemoryOrganization, M: MemoryMember, I: MemoryInvitation, V: MemoryVerification, P: MemoryPasskey,

type TwoFactor = TwoFactor

fn create_two_factor<'life0, 'async_trait>( &'life0 self, create: CreateTwoFactor, ) -> Pin<Box<dyn Future<Output = Result<TwoFactor, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_two_factor_by_user_id<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<TwoFactor>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn update_two_factor_backup_codes<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, user_id: &'life1 str, backup_codes: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<TwoFactor, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn delete_two_factor<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

impl<U, S, A, O, M, I, V, P> UserOps for MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>

where U: MemoryUser, S: MemorySession, A: MemoryAccount, O: MemoryOrganization, M: MemoryMember, I: MemoryInvitation, V: MemoryVerification, P: MemoryPasskey,

type User = U

fn create_user<'life0, 'async_trait>( &'life0 self, create_user: CreateUser, ) -> Pin<Box<dyn Future<Output = Result<U, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_user_by_id<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<U>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_user_by_email<'life0, 'life1, 'async_trait>( &'life0 self, email: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<U>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_user_by_username<'life0, 'life1, 'async_trait>( &'life0 self, username: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<U>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn update_user<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, update: UpdateUser, ) -> Pin<Box<dyn Future<Output = Result<U, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn delete_user<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn list_users<'life0, 'async_trait>( &'life0 self, params: ListUsersParams, ) -> Pin<Box<dyn Future<Output = Result<(Vec<U>, usize), AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

List users with optional filtering, sorting, and pagination. Returns (users, total_count).

impl<U, S, A, O, M, I, V, P> VerificationOps for MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>

where U: MemoryUser, S: MemorySession, A: MemoryAccount, O: MemoryOrganization, M: MemoryMember, I: MemoryInvitation, V: MemoryVerification, P: MemoryPasskey,

type Verification = V

fn create_verification<'life0, 'async_trait>( &'life0 self, create_verification: CreateVerification, ) -> Pin<Box<dyn Future<Output = Result<V, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_verification<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, identifier: &'life1 str, value: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<V>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_verification_by_value<'life0, 'life1, 'async_trait>( &'life0 self, value: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<V>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn get_verification_by_identifier<'life0, 'life1, 'async_trait>( &'life0 self, identifier: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<V>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn consume_verification<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, identifier: &'life1 str, value: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<V>, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

Atomically consume a verification token identified by (identifier, value).

fn delete_verification<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,

fn delete_expired_verifications<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<usize, AuthError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryDatabaseAdapter<U, S, A, O, M, I, V, P>: 'async_trait,