Struct Auth 

pub struct Auth;

Authentication facade

Provides Laravel-like static methods for authentication operations.

Example

use ferro_rs::Auth;

// Check if authenticated
if Auth::check() {
    let user_id = Auth::id().unwrap();
}

// Log in
Auth::login(user_id);

// Log out
Auth::logout();

Implementations

impl Auth

pub fn id() -> Option<i64>

Get the authenticated user’s ID

Returns None if not authenticated.

pub fn id_as<T>() -> Option<T>

where T: TryFrom<i64>,

Get the authenticated user’s ID as a specific type

Useful when your database uses i32 primary keys but Auth stores i64.

Example

// SeaORM entities typically use i32 for primary keys
let user_id: i32 = Auth::id_as().expect("User must be authenticated");

pub fn check() -> bool

Check if a user is currently authenticated

pub fn guest() -> bool

Check if the current user is a guest (not authenticated)

pub fn login(user_id: i64)

Log in a user by their ID

This sets the user ID in the session, making them authenticated.

Security

This method regenerates the session ID to prevent session fixation attacks.

pub fn login_remember(user_id: i64, _remember_token: &str)

Log in a user with “remember me” functionality

This extends the session lifetime for persistent login.

Arguments

• user_id - The user’s ID
• remember_token - A secure token for remember me cookie

pub fn logout()

Log out the current user

Clears the authenticated user from the session.

Security

This regenerates the CSRF token to prevent any cached tokens from being reused.

pub fn logout_and_invalidate()

Log out and invalidate the entire session

Use this for complete session destruction (e.g., “logout everywhere”).

pub async fn logout_other_devices() -> Option<Result<u64, FrameworkError>>

Log out all other sessions for the current user.

Destroys all sessions for the authenticated user except the current one. Use after password changes or security-sensitive operations.

Returns the number of destroyed sessions, or None if not authenticated.

pub async fn attempt<F, Fut>( validator: F, ) -> Result<Option<i64>, FrameworkError>

where F: FnOnce() -> Fut, Fut: Future<Output = Result<Option<i64>, FrameworkError>>,

Attempt to authenticate with a validator function

The validator function should return the user ID if credentials are valid.

Example

let user_id = Auth::attempt(async {
    // Validate credentials
    let user = User::find_by_email(&email).await?;
    if user.verify_password(&password)? {
        Ok(Some(user.id))
    } else {
        Ok(None)
    }
}).await?;

if let Some(id) = user_id {
    // Authentication successful
}

pub async fn validate<F, Fut>(validator: F) -> Result<bool, FrameworkError>

where F: FnOnce() -> Fut, Fut: Future<Output = Result<bool, FrameworkError>>,

Validate credentials without logging in

Useful for password confirmation dialogs.

pub async fn user() -> Result<Option<Arc<dyn Authenticatable>>, FrameworkError>

Get the currently authenticated user

Returns None if not authenticated or if no UserProvider is registered.

Example

use ferro_rs::Auth;

if let Some(user) = Auth::user().await? {
    println!("Logged in as user {}", user.auth_identifier());
}

Errors

Returns an error if no UserProvider is registered in the container. Make sure to register a UserProvider in your bootstrap.rs:

bind!(dyn UserProvider, DatabaseUserProvider);

pub async fn user_as<T: Authenticatable + Clone>() -> Result<Option<T>, FrameworkError>

Get the authenticated user, cast to a concrete type

This is a convenience method that retrieves the user and downcasts it to your concrete User type.

Example

use ferro_rs::Auth;
use ferro_rs::models::users::User;

if let Some(user) = Auth::user_as::<User>().await? {
    println!("Welcome, user #{}!", user.id);
}

Type Parameters

• T - The concrete user type that implements Authenticatable and Clone