Laravel Authentication vs. Authorization

Let's dive into the details:

1. Authentication vs. Authorization

Authentication is the process of identifying who a user is, while Authorization is the process of determining what that user is allowed to do.

Authentication:

• Primarily concerns itself with verifying the identity of a user.
• For example, when a user logs in with their username and password, they are being authenticated.

Authorization:

• Once a user is authenticated, authorization defines what actions they are permitted to perform.
• For instance, after logging in, can a user edit a particular resource or view a certain page? This is where authorization comes into play.

2. Laravel's Tools for Authentication

Laravel has various tools and packages that provide scaffolding and functionality for authentication:

1. Laravel UI: A simple frontend scaffolding for Laravel that provides basic Bootstrap views and controllers for registration, login, password reset, etc.

   composer require laravel/ui
   php artisan ui bootstrap --auth

2. Laravel Breeze: A minimalist scaffolding for authentication that uses Blade and Tailwind CSS. It offers a simple starting point for basic authentication.

   composer require laravel/breeze --dev
   php artisan breeze:install

3. Laravel Jetstream: A more advanced scaffolding that provides features like profile management, two-factor authentication, and team management. It uses Livewire or Inertia.js as its stack.

   composer require laravel/jetstream
   php artisan jetstream:install livewire

4. Laravel Fortify: A backend-only package that provides the authentication logic without any frontend scaffolding. You can use it to build your custom frontend while leveraging Fortify's backend authentication logic.

3. Laravel's Tools for Authorization

Gates and Policies are two primary mechanisms Laravel provides for Authorization.

Gates:

• Gates are closure-based, simple authorization logic.
• Typically defined in App\Providers\AuthServiceProvider.

• Great for authorizing actions that aren't necessarily tied to any particular model.

  use Illuminate\Support\Facades\Gate;
  
  Gate::define('update-post', function ($user, $post) {
    return $user->id == $post->user_id;
  });

You can check if a user is authorized using the allows or denies methods:

if (Gate::allows('update-post', $post)) {
    // The current user can update the post...
}

Policies:

• Policies are class-based and are tied to a particular model.
• Great for authorizing actions on a model (e.g., Post).

First, generate a policy:

php artisan make:policy PostPolicy --model=Post

Then, within the policy:

public function update(User $user, Post $post)
{
    return $user->id === $post->user_id;
}

You can then authorize actions in controllers:

public function edit($id)
{
    $post = Post::find($id);
    $this->authorize('update', $post);
    // ...
}

What I'm building

Delegate tasks. Get software.

Give Vroni a GitHub issue, bug report, spec, or rough idea. It reads the repo, plans the change, writes code, runs checks, and works toward a review-ready pull request.

Take a look at vroni.com