Mastering Authentication with Breeze and Spatie: A Step-by-Step Guide to Role-Based Permissions

In the world of Laravel development, authentication and permission management are crucial aspects of building a secure and scalable application. In this article, we’ll explore how to implement role-based authentication using Breeze and Spatie, two popular Laravel packages. By the end of this tutorial, you’ll have a comprehensive understanding of how to create a robust permission system that’s tailored to your application’s unique needs.

What is Breeze and Spatie?

Breeze is a Laravel package that provides a simple and intuitive way to implement authentication in your application. It’s developed by the Laravel team and is designed to be fast, secure, and easy to use. Spatie, on the other hand, is a separate package that focuses on permission management. It provides a robust and flexible system for managing permissions, roles, and users.

Setting Up the Environment

Before we dive into the implementation, make sure you have the following installed:

• Laravel 8.x or higher
• Breeze package ( installing via composer: `composer require laravel/breeze`)
• Spatie package (installing via composer: `composer require spatie/laravel-permission`)

Configuring Breeze

First, let’s set up Breeze to handle authentication in our application. Run the following command in your terminal:

php artisan breeze:install

This command will install the necessary files and configurations for Breeze. Next, publish the config file using:

php artisan vendor:publish --tag=breeze-config

Open the `config/breeze.php` file and update the `guards` section to use the `web` guard:

    'guards' => [
        'web' => [
            'driver' => 'session',
            'provider' => null,
        ],
    ],

Implementing Role-Based Authentication with Breeze

Now that Breeze is configured, let’s create a role-based authentication system. We’ll create three roles: `admin`, `moderator`, and `user`. Create a new migration file using:

php artisan make:migration create_roles_table

In the migration file, add the following code:

    public function up()
    {
        Schema::create('roles', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('description');
            $table->timestamps();
        });
    }

Run the migration using:

php artisan migrate

Next, create a new seeder file using:

php artisan make:seeder RoleSeeder

In the seeder file, add the following code:

    public function run()
    {
        DB::table('roles')->insert([
            ['name' => 'admin', 'description' => 'Administrator role'],
            ['name' => 'moderator', 'description' => 'Moderator role'],
            ['name' => 'user', 'description' => 'User role'],
        ]);
    }

Run the seeder using:

php artisan db:seed --class=RoleSeeder

Integrating Spatie for Permission Management

Now that we have our roles set up, let’s integrate Spatie to handle permission management. First, publish the Spatie config file using:

php artisan vendor:publish --tag=laravel-permission-config

Open the `config/laravel-permission.php` file and update the `models` section to use the `App\Models\User` model:

    'models' => [
        'permission' => App\Models\Permission::class,
        'role' => App\Models\Role::class,
    ],

Defining Permissions

Create a new migration file using:

php artisan make:migration create_permissions_table

In the migration file, add the following code:

    public function up()
    {
        Schema::create('permissions', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('description');
            $table->timestamps();
        });
    }

Run the migration using:

php artisan migrate

Next, create a new seeder file using:

php artisan make:seeder PermissionSeeder

In the seeder file, add the following code:

    public function run()
    {
        DB::table('permissions')->insert([
            ['name' => 'view_dashboard', 'description' => 'View dashboard'],
            ['name' => 'manage_users', 'description' => 'Manage users'],
            ['name' => 'edit_articles', 'description' => 'Edit articles'],
        ]);
    }

Run the seeder using:

php artisan db:seed --class=PermissionSeeder

Assigning Permissions to Roles

Now that we have our permissions set up, let’s assign them to our roles. Create a new seeder file using:

php artisan make:seeder RolePermissionSeeder

In the seeder file, add the following code:

    public function run()
    {
        $adminRole = App\Models\Role::where('name', 'admin')->first();
        $moderatorRole = App\Models\Role::where('name', 'moderator')->first();
        $userRole = App\Models\Role::where('name', 'user')->first();

        $viewDashboardPermission = App\Models\Permission::where('name', 'view_dashboard')->first();
        $manageUsersPermission = App\Models\Permission::where('name', 'manage_users')->first();
        $editArticlesPermission = App\Models\Permission::where('name', 'edit_articles')->first();

        $adminRole->givePermissionTo($viewDashboardPermission);
        $adminRole->givePermissionTo($manageUsersPermission);
        $adminRole->givePermissionTo($editArticlesPermission);

        $moderatorRole->givePermissionTo($viewDashboardPermission);
        $moderatorRole->givePermissionTo($editArticlesPermission);

        $userRole->givePermissionTo($viewDashboardPermission);
    }

Run the seeder using:

php artisan db:seed --class=RolePermissionSeeder

Using Breeze and Spatie in Your Application

Now that we have our role-based authentication and permission system set up, let’s use it in our application. Create a new middleware file using:

php artisan make:middleware CheckPermission

In the middleware file, add the following code:

    public function handle(Request $request, Closure $next)
    {
        $role = auth()->user()->role;
        $permission = $request->route()->getName();

        if (!$role->hasPermissionTo($permission)) {
            abort(403);
        }

        return $next($request);
    }

Register the middleware in the `kernel.php` file:

    protected $middleware = [
        // ...
        \App\Http\Middleware\CheckPermission::class,
    ];

Now, when a user tries to access a route, the middleware will check if they have the required permission. If they don’t, a 403 error will be thrown.

Conclusion

In this article, we’ve covered how to implement role-based authentication with Breeze and permission management with Spatie. By following these steps, you can create a robust and scalable permission system that’s tailored to your application’s unique needs. Remember to always follow best practices and security guidelines when implementing authentication and permission systems in your application.

Package	Description
Breeze	Laravel package for authentication
Spatie	Laravel package for permission management

By mastering Breeze and Spatie, you can take your Laravel application to the next level and build a secure and scalable permission system that meets your users’ needs.

1. Set up Breeze for authentication
2. Implement role-based authentication with Breeze
3. Integrate Spatie for permission management
4. Define permissions and assign them to roles
5. Use Breeze and Spatie in your application

Frequently Asked Questions

Get the scoop on authenticating with Breeze based on roles and using Spatie for handling permissions!