rez1pro/user-access

Laravel UserAccess package for roles & permissions using models, enums, and facades.

1.2.2 2025-11-17 08:24 UTC

MIT

• Rezwan Hossain Sajib

README

A Laravel package to manage Roles & Permissions using Models, Enums, and Facade support.
Easily integrate role-based access control into your application.

🚀 Installation

1. Require the package

composer require rez1pro/user-access

2. Service Provider

The service provider is auto-discovered.
If needed, register manually in config/app.php:

'providers' => [
    Rez1pro\UserAccess\UserAccessServiceProvider::class,
]

⚡ Installer Command

For a one-shot setup:

php artisan user-access:install --force
php artisan migrate

This will:

• Publish config
• Publish migrations
• Publish models
• Publish enums
• Run database migrations

📸 Screenshots

Installation

Permission Management

When run rollback

Permission Management

🗄️ Database Schema

The migration will create the following tables:

• roles
• permissions
• role_has_permissions (pivot)

👤 User Model Integration

Add the HasPermission trait to your User model:

use Rez1pro\UserAccess\Traits\HasPermission;

class User extends Authenticatable
{
    use HasPermission;
    
    // ...existing code...
}

User Permission Methods

$user = User::find(1);

// Assign role to user
$user->assignRole('admin');
$user->assignRole(['admin', 'editor']);

// Check if user has role
$user->hasRole('admin'); // true/false
$user->hasAnyRole(['admin', 'editor']); // true/false

// Check if user has permission
$user->hasPermissionTo('create:user'); // true/false
$user->hasPermissionTo(ExamplePermissionEnum::CREATE_USER); // true/false

// Get user roles and permissions
$user->roles; // Collection of roles
$user->permissions; // Collection of permissions through roles

// Remove role from user
$user->removeRole('admin');

🧩 Models

The package ships with:

• App\Models\Role
• App\Models\Permission

Role Model Usage

use App\Models\Role;

// Create role
$role = Role::create(['name' => 'Admin']);

// Assign permissions to role
$role->givePermissionTo(ExamplePermissionEnum::CREATE_USER);
$role->givePermissionTo(['create:user', 'edit:user']);

// Check role permissions
$role->hasPermissionTo(ExamplePermissionEnum::CREATE_USER); // true/false

// Get role permissions
$role->permissions; // Collection of permissions

// Remove permission from role
$role->removePermission(ExamplePermissionEnum::CREATE_USER);

Permission Model Usage

use App\Models\Permission;

$permission = Permission::where('name', 'create:user')->first();

// Get all roles that have this permission
$permission->roles; // Collection of roles

🏷️ Enums

Enums are placed in App\Enums\Permissions.

Example:

use Rez1pro\UserAccess\Traits\HasAccess;

enum ExamplePermissionEnum: string
{
    use HasAccess;

    case VIEW_EXAMPLE = 'view:example';
    case CREATE_EXAMPLE = 'create:example';
    case EDIT_EXAMPLE = 'edit:example';
    case DELETE_EXAMPLE = 'delete:example';
}

Usage:

ExamplePermissionEnum::VIEW_EXAMPLE->value; // "view:example"

Permission Commands

# Create new permission enums
php artisan permission:create

# Insert all permissions to database
php artisan permission:insert

# Remove permissions from database
php artisan permission:rollback

# Delete all existing permissions and re-insert them (fresh start)
php artisan permission:fresh

After running rollback command:

namespace App\Enums\Permissions;

use Rez1pro\UserAccess\Traits\HasAccess;

enum ExamplePermissionEnum: string
{
    use HasAccess;

    // case VIEW_EXAMPLE = 'view:example'; // commented by UserAccess package
    case CREATE_EXAMPLE = 'create:example';
}

The permission:fresh command is useful when you want to:

• Reset all permissions to match your current enum definitions
• Clean up old/unused permissions from the database
• Sync permissions after major enum changes
• Note: This will temporarily disable foreign key checks to allow deletion, then re-insert all permissions from your enums

🎭 Facade

The UserAccess Facade provides quick helpers:

use Rez1pro\UserAccess\Facades\UserAccess;

// Get all permissions as array
$permissions = UserAccess::all(); 
// Returns: ['view:example', 'create:example']

// Get permissions grouped by enum
$permissionWithGroups = UserAccess::withGroup();

Returns JSON structure:

[
    {
        "name": "Example Permission Enum",
        "permissions": [
            {
                "id": "view:example",
                "name": "VIEW EXAMPLE"
            },
            {
                "id": "create:example",
                "name": "CREATE EXAMPLE"
            }
        ]
    }
]

🔐 Practical Usage Examples

Complete User Role & Permission Setup

use App\Models\User;
use App\Models\Role;
use App\Enums\Permissions\ExamplePermissionEnum;

// Create a role
$adminRole = Role::create(['name' => 'admin']);

// Assign permissions to role
$adminRole->givePermissionTo([
    ExamplePermissionEnum::VIEW_EXAMPLE,
    ExamplePermissionEnum::CREATE_EXAMPLE,
    ExamplePermissionEnum::EDIT_EXAMPLE
]);

// Assign role to user
$user = User::find(1);
$user->assignRole('admin');

// Check user permissions
if ($user->hasPermissionTo(ExamplePermissionEnum::CREATE_EXAMPLE)) {
    // User can create examples
}

// In your controllers/middleware
if (auth()->user()->hasPermissionTo('edit:example')) {
    // Allow edit action
}

Middleware Usage

// In your routes
Route::middleware(['auth', 'permission:create:user'])->group(function () {
    Route::post('/users', [UserController::class, 'store']);
});

// Or check in controller
public function store(Request $request)
{
    if (!auth()->user()->hasPermissionTo('create:user')) {
        abort(403, 'Unauthorized');
    }
    
    // Create user logic
}

📌 Summary

• php artisan user-access:install → Quick setup
• UserAccess Facade → Easy access to roles & permissions
• HasPermission Trait → Add to User model for permission checking
• Enums → Strongly typed permissions
• Models → Extendable Role and Permission models
• Migrations → Published and customizable

📝 License

This package is open-sourced software licensed under the MIT license.