Struct IdentityService 

pub struct IdentityService { /* private fields */ }

Composes every collaborator needed for the core auth flows. Cheap to clone (all fields are Arc), so it can be provided and injected freely.

Implementations

impl IdentityService

pub fn builder( users: Arc<dyn UserStore>, creds: Arc<dyn CredentialStore>, hasher: Arc<dyn PasswordHasher>, jwt: Arc<JwtService>, refresh: Arc<dyn RefreshStore>, challenges: Arc<dyn ChallengeStore>, ) -> IdentityServiceBuilder

Start building. Required collaborators are passed here; optional ones (lockout, MFA) and config are attached fluently.

pub async fn register(&self, req: RegisterRequest) -> Result<Identity>

Register a new user. Hashes the password (if any) off the reactor, stores the identity, and returns it. Does not issue tokens — callers usually send a verification email first.

pub async fn login( &self, tenant: Option<&str>, email: &str, password: &str, ) -> Result<LoginOutcome>

Authenticate with email + password. Returns either issued tokens or an MFA challenge. principal_ip seeds lockout before the user is known.

pub async fn login_bound( &self, tenant: Option<&str>, email: &str, password: &str, cnf_jkt: Option<&str>, ) -> Result<LoginOutcome>

Like login but sender-constrains the issued access token to a DPoP key (cnf_jkt from a verified proof, RFC 9449 / H3). The binding is applied on the direct-auth path; when MFA is enrolled the challenge path mints in verify_mfa (unbound for now).

pub async fn verify_mfa( &self, challenge_id: &str, method: &str, code: &str, ) -> Result<TokenResponse>

Complete a pending MFA challenge with a factor response (method = e.g. "totp" / "recovery", code = the user-supplied value).

pub async fn login_federated( &self, tenant: Option<&str>, profile: &FederatedProfile, signal: Option<RiskSignal>, ) -> Result<FederatedOutcome>

Authenticate a user from an external identity provider (social login / enterprise SSO), applying the takeover-safe linking policy, optional risk step-up, and auditing — then minting through the same path as password login. signal (when a RiskEngine is configured) drives adaptive MFA.

See crate::federation for the security rationale behind each branch.

pub async fn link_federated( &self, user_id: &str, profile: &FederatedProfile, ) -> Result<()>

Explicitly link an external identity to an already-authenticated local user (user_id). This is the takeover-proof path the app runs after the user proves ownership of the local account, in response to a FederatedOutcome::LinkRequired.

pub async fn refresh(&self, refresh_token: &str) -> Result<TokenResponse>

Rotate a refresh token: validate signature + stored jti, atomically consume the old jti, and issue a fresh pair. Reuse of a consumed token fails closed.

pub async fn logout(&self, refresh_token: &str) -> Result<()>

Revoke a specific refresh token (single-device logout).

pub async fn logout_all(&self, user_id: &str) -> Result<()>

Revoke every refresh token for a user (“log out everywhere”).

pub async fn me(&self, user_id: &str) -> Result<Identity>

Fetch the current identity by id (for /auth/me).

pub async fn mint(&self, user: &Identity) -> Result<TokenResponse>

Mint an access+refresh pair for an authenticated identity and persist the refresh jti for rotation.

pub async fn mint_bound( &self, user: &Identity, cnf_jkt: Option<&str>, ) -> Result<TokenResponse>

Like mint but sender-constrains the access token to a DPoP key thumbprint (RFC 9449, H3). cnf_jkt comes from a verified DpopProof; the resource server then requires a matching proof on every request, so a leaked token can’t be replayed.

Trait Implementations

impl Clone for IdentityService

fn clone(&self) -> IdentityService

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.