Authentication Service

The Spark Authentication Service provides a robust, driver-based authentication system with session management, remember me functionality, route protection, and user caching.

Configuration

Register and configure the Auth service in your AppServiceProvider:

use Spark\Http\Auth;
use App\Models\User;

$container->singleton(Auth::class, function(Container $container) {
    return new Auth(
        $container->get(Session::class),
        User::class,
        [
            'session_key' => 'user_id',
            'cache_enabled' => true,
            'cache_name' => 'auth_cache',
            'cache_expire' => '30 minutes',
            'guest_route' => 'login',
            'logged_in_route' => 'dashboard',
            'cookie_enabled' => true,
            'cookie_name' => 'logged_user_token',
            'cookie_expire' => '30 days',
            'driver' => null
        ]
    );
});

Configuration Options

Core Methods

$user = $auth->getUser();
if ($user !== false) {
    echo "Welcome, {$user->name}";
}

// Get entire user model
$user = $auth->user();

// Get specific attribute
$email = $auth->user('email');

// With default value
$phone = $auth->user('phone', 'No phone set');

// Basic login
$auth->login($user);

// With remember me
$auth->login($user, true);

$auth->logout();

if ($auth->isGuest()) {
    return redirect('login');
}

// After updating user profile
$auth->refresh();

Authentication Drivers

Implement custom authentication logic by creating a driver:

use Spark\Contracts\Http\AuthDriverContract;

class CustomAuthDriver implements AuthDriverContract
{
    public function getUser(): false|Model
    {
        // Custom logic to retrieve user
    }

    public function login(Model $user, bool $remember = false): void
    {
        // Custom login handling
    }

    public function logout(): void
    {
        // Custom logout handling
    }
}

// Configure the driver
$auth->configure(['driver' => new CustomAuthDriver()]);

Remember Me Functionality

Secure remember me implementation using encrypted cookies:

// Configuration
'cookie_enabled' => true,
'cookie_name' => 'auth_token',
'cookie_expire' => '30 days',

// During login
$auth->login($user, true); // Second parameter enables remember me

// Automatic authentication flow:
// 1. Checks session for user ID
// 2. If no session, checks 'auth_token' cookie
// 3. Validates cookie, logs in user if valid
// 4. Sets new session

User Caching

Improve performance by caching authenticated users:

// Enable caching
'cache_enabled' => true,
'cache_name' => 'auth_users',
'cache_expire' => '1 hour',

// Caching behavior:
// - User cached on first access after login
// - Cache cleared on logout or refresh
// - Automatically used by getUser()

Route Protection

Example auth middleware implementation:

class AuthMiddleware
{
    public function handle($request, $next)
    {
        if (auth()->isGuest()) {
            return redirect(auth()->getGuestRoute());
        }

        return $next($request);
    }
}

// Register middleware
Route::group(['middleware' => 'auth'], function() {
    // Protected routes
});

Full Authentication Flow Example

// Login Controller
public function authenticate(Request $request, Auth $auth, Hash $hash)
{
    $credentials = $request->validate([
        'email' => 'required|email',
        'password' => 'required'
    ]);

    $user = User::where('email', $credentials['email'])->first();

    if ($user && $hash->validatePassword($credentials['password'], $user->password)) {
        $auth->login($user, $request->has('remember'));
        
        return redirect($auth->getLoggedInRoute());
    }

    return back()->with('error', 'Invalid credentials');
}

// Dashboard Controller
public function dashboard(Auth $auth)
{
    return view('dashboard', [
        'user' => $auth->user()
    ]);
}

// Logout Controller
public function logout(Auth $auth)
{
    $auth->logout();
    return redirect('/');
}