Cara Membuat Role dan Permission Laravel Tanpa Package

Apa Itu Role dan Permission?

Role adalah kelompok atau jabatan yang diberikan kepada pengguna.

Contoh role dalam sebuah aplikasi:

1. Super Administrator.

2. Administrator.

3. Manager.

4. Kasir.

5. Staff Gudang.

6. Dokter.

7. Customer Service.

8. Pengguna biasa.

Permission adalah izin untuk menjalankan tindakan tertentu.

Contoh permission:

1. Melihat pengguna.

2. Menambahkan pengguna.

3. Mengubah pengguna.

4. Menghapus pengguna.

5. Melihat produk.

6. Menambahkan produk.

7. Mengubah produk.

8. Menghapus produk.

9. Melihat laporan.

10. Mengatur sistem.

Satu role dapat memiliki banyak permission. Satu pengguna juga dapat memiliki satu atau beberapa role, tergantung kebutuhan aplikasi.

Sebagai contoh, role kasir dapat memiliki permission:

transactions.view
transactions.create
products.view
customers.view

Sementara role administrator dapat memiliki permission yang lebih luas.

Perbedaan Role dan Permission

Role menjelaskan posisi pengguna dalam sistem.

Permission menjelaskan tindakan yang dapat dilakukan pengguna.

Contohnya:

Role: Staff Gudang

Permission yang dimiliki:

products.view
stock.view
stock.update
stock.transfer
purchase.create

Penggunaan permission membuat hak akses lebih fleksibel. Ketika terdapat perubahan kebutuhan, administrator cukup menambahkan atau mengurangi permission pada role tanpa harus mengubah source code di banyak tempat.

Apakah Laravel Memiliki Sistem Authorization?

Laravel menyediakan sistem authorization bawaan menggunakan Gate dan Policy.

Gate cocok untuk pemeriksaan izin sederhana berbasis kemampuan tertentu. Policy digunakan untuk mengelompokkan aturan authorization berdasarkan model atau resource, misalnya izin melihat, memperbarui, dan menghapus produk.

Namun, Laravel tidak menyediakan tabel role dan permission secara otomatis. Struktur database serta hubungan antarrole perlu dibuat sesuai kebutuhan aplikasi.

Pada tutorial ini, sistem akan menggunakan:

1. Tabel roles.

2. Tabel permissions.

3. Tabel penghubung role_user.

4. Tabel penghubung permission_role.

5. Middleware role.

6. Middleware permission.

7. Gate Laravel.

8. Blade Directive.

Struktur Database Role dan Permission

Relasi yang akan digunakan adalah:

users
  ↕
role_user
  ↕
roles
  ↕
permission_role
  ↕
permissions

Hubungannya adalah:

• Satu pengguna dapat mempunyai banyak role.

• Satu role dapat dimiliki banyak pengguna.

• Satu role dapat mempunyai banyak permission.

• Satu permission dapat digunakan oleh banyak role.

Eloquent menyediakan relasi belongsToMany untuk mengelola hubungan many-to-many menggunakan tabel perantara atau pivot. Dokumentasi Laravel juga menggunakan contoh pengguna yang dapat memiliki banyak role melalui tabel role_user.

Langkah 1: Membuat Model dan Migration

Jalankan perintah berikut:

php artisan make:model Role -m
php artisan make:model Permission -m

php artisan make:migration create_role_user_table
php artisan make:migration create_permission_role_table

Perintah tersebut akan membuat:

app/Models/Role.php
app/Models/Permission.php
database/migrations/create_roles_table.php
database/migrations/create_permissions_table.php
database/migrations/create_role_user_table.php
database/migrations/create_permission_role_table.php

Langkah 2: Membuat Tabel Roles

Buka migration:

database/migrations/xxxx_xx_xx_create_roles_table.php

Isi method up():

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

Contoh data role:

name: Administrator
slug: administrator

Gunakan slug sebagai nilai yang diperiksa dalam source code karena lebih konsisten dibandingkan nama yang dapat berubah untuk kebutuhan tampilan.

Langkah 3: Membuat Tabel Permissions

Buka migration:

database/migrations/xxxx_xx_xx_create_permissions_table.php

Isi method up():

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

Contoh data permission:

name: Melihat Pengguna
slug: users.view
group: users

Kolom group digunakan agar permission lebih mudah dikelompokkan pada halaman pengaturan hak akses.

Langkah 4: Membuat Tabel Role User

Buka migration:

database/migrations/xxxx_xx_xx_create_role_user_table.php

Isi:

public function up(): void
{
    Schema::create('role_user', function (Blueprint $table) {
        $table->id();

        $table->foreignId('user_id')
            ->constrained()
            ->cascadeOnDelete();

        $table->foreignId('role_id')
            ->constrained()
            ->cascadeOnDelete();

        $table->timestamps();

        $table->unique(['user_id', 'role_id']);
    });
}

Tabel ini menghubungkan pengguna dengan role.

Penggunaan kombinasi unique mencegah role yang sama diberikan dua kali kepada satu pengguna.

Langkah 5: Membuat Tabel Permission Role

Buka migration:

database/migrations/xxxx_xx_xx_create_permission_role_table.php

Isi:

public function up(): void
{
    Schema::create('permission_role', function (Blueprint $table) {
        $table->id();

        $table->foreignId('permission_id')
            ->constrained()
            ->cascadeOnDelete();

        $table->foreignId('role_id')
            ->constrained()
            ->cascadeOnDelete();

        $table->timestamps();

        $table->unique(['permission_id', 'role_id']);
    });
}

Tabel ini digunakan untuk menentukan permission yang dimiliki oleh setiap role.

Langkah 6: Menjalankan Migration

Setelah semua migration selesai, jalankan:

php artisan migrate

Periksa database dan pastikan tabel berikut tersedia:

users
roles
permissions
role_user
permission_role

Untuk melihat status migration:

php artisan migrate:status

Langkah 7: Mengatur Model Role

Buka:

app/Models/Role.php

Isi dengan kode berikut:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;

class Role extends Model
{
    protected $fillable = [
        'name',
        'slug',
        'description',
    ];

    public function users(): BelongsToMany
    {
        return $this->belongsToMany(User::class)
            ->withTimestamps();
    }

    public function permissions(): BelongsToMany
    {
        return $this->belongsToMany(Permission::class)
            ->withTimestamps();
    }
}

Method users() menghubungkan role dengan pengguna.

Method permissions() menghubungkan role dengan daftar izin yang dimilikinya.

Langkah 8: Mengatur Model Permission

Buka:

app/Models/Permission.php

Isi:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;

class Permission extends Model
{
    protected $fillable = [
        'name',
        'slug',
        'group',
        'description',
    ];

    public function roles(): BelongsToMany
    {
        return $this->belongsToMany(Role::class)
            ->withTimestamps();
    }
}

Langkah 9: Menambahkan Relasi pada Model User

Buka:

app/Models/User.php

Tambahkan import:

use Illuminate\Database\Eloquent\Relations\BelongsToMany;

Tambahkan relasi dan helper berikut di dalam class User:

public function roles(): BelongsToMany
{
    return $this->belongsToMany(Role::class)
        ->withTimestamps();
}

public function hasRole(string ...$roles): bool
{
    return $this->roles()
        ->whereIn('slug', $roles)
        ->exists();
}

public function hasAnyRole(array $roles): bool
{
    return $this->roles()
        ->whereIn('slug', $roles)
        ->exists();
}

public function hasPermission(string $permission): bool
{
    return $this->roles()
        ->whereHas('permissions', function ($query) use ($permission) {
            $query->where('slug', $permission);
        })
        ->exists();
}

public function hasAnyPermission(array $permissions): bool
{
    return $this->roles()
        ->whereHas('permissions', function ($query) use ($permissions) {
            $query->whereIn('slug', $permissions);
        })
        ->exists();
}

Sekarang role dapat diperiksa menggunakan:

$user->hasRole('administrator');

Beberapa role sekaligus:

$user->hasRole('administrator', 'manager');

Permission dapat diperiksa menggunakan:

$user->hasPermission('users.create');

Langkah 10: Membuat Seeder Role dan Permission

Jalankan:

php artisan make:seeder RolePermissionSeeder

Seeder Laravel disimpan di dalam folder database/seeders dan dijalankan melalui perintah db:seed. Seeder dapat menggunakan Eloquent atau Query Builder untuk memasukkan data awal ke database.

Buka:

database/seeders/RolePermissionSeeder.php

Isi:

<?php

namespace Database\Seeders;

use App\Models\Permission;
use App\Models\Role;
use App\Models\User;
use Illuminate\Database\Seeder;

class RolePermissionSeeder extends Seeder
{
    public function run(): void
    {
        $permissions = [
            [
                'name' => 'Melihat Pengguna',
                'slug' => 'users.view',
                'group' => 'users',
            ],
            [
                'name' => 'Menambahkan Pengguna',
                'slug' => 'users.create',
                'group' => 'users',
            ],
            [
                'name' => 'Mengubah Pengguna',
                'slug' => 'users.update',
                'group' => 'users',
            ],
            [
                'name' => 'Menghapus Pengguna',
                'slug' => 'users.delete',
                'group' => 'users',
            ],
            [
                'name' => 'Melihat Produk',
                'slug' => 'products.view',
                'group' => 'products',
            ],
            [
                'name' => 'Menambahkan Produk',
                'slug' => 'products.create',
                'group' => 'products',
            ],
            [
                'name' => 'Mengubah Produk',
                'slug' => 'products.update',
                'group' => 'products',
            ],
            [
                'name' => 'Menghapus Produk',
                'slug' => 'products.delete',
                'group' => 'products',
            ],
            [
                'name' => 'Melihat Laporan',
                'slug' => 'reports.view',
                'group' => 'reports',
            ],
        ];

        foreach ($permissions as $permission) {
            Permission::updateOrCreate(
                ['slug' => $permission['slug']],
                $permission
            );
        }

        $superAdmin = Role::updateOrCreate(
            ['slug' => 'super-admin'],
            ['name' => 'Super Administrator']
        );

        $administrator = Role::updateOrCreate(
            ['slug' => 'administrator'],
            ['name' => 'Administrator']
        );

        $staff = Role::updateOrCreate(
            ['slug' => 'staff'],
            ['name' => 'Staff']
        );

        $superAdmin->permissions()->sync(
            Permission::query()->pluck('id')
        );

        $administrator->permissions()->sync(
            Permission::query()
                ->whereIn('slug', [
                    'users.view',
                    'users.create',
                    'users.update',
                    'products.view',
                    'products.create',
                    'products.update',
                    'reports.view',
                ])
                ->pluck('id')
        );

        $staff->permissions()->sync(
            Permission::query()
                ->whereIn('slug', [
                    'products.view',
                ])
                ->pluck('id')
        );

        $user = User::query()
            ->where('email', 'admin@example.com')
            ->first();

        if ($user) {
            $user->roles()->sync([$superAdmin->id]);
        }
    }
}

Method sync() mengganti isi relasi many-to-many agar hanya ID yang diberikan yang tersimpan pada tabel pivot. ID lama yang tidak terdapat dalam daftar akan dilepas dari relasi.

Langkah 11: Menjalankan Seeder

Panggil seeder pada:

database/seeders/DatabaseSeeder.php

Isi:

public function run(): void
{
    $this->call([
        RolePermissionSeeder::class,
    ]);
}

Jalankan:

php artisan db:seed

Atau jalankan seeder tertentu:

php artisan db:seed --class=RolePermissionSeeder

Pada server production, gunakan:

php artisan db:seed --class=RolePermissionSeeder --force

Langkah 12: Membuat Middleware Role

Jalankan:

php artisan make:middleware RoleMiddleware

Buka:

app/Http/Middleware/RoleMiddleware.php

Isi:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class RoleMiddleware
{
    public function handle(
        Request $request,
        Closure $next,
        string ...$roles
    ): Response {
        $user = $request->user();

        if (! $user) {
            abort(401, 'Anda harus login terlebih dahulu.');
        }

        if (! $user->hasAnyRole($roles)) {
            abort(403, 'Anda tidak memiliki role yang diperlukan.');
        }

        return $next($request);
    }
}

Middleware digunakan untuk memeriksa dan menyaring request sebelum diteruskan ke route atau controller. Middleware custom Laravel umumnya ditempatkan di dalam folder app/Http/Middleware.

Langkah 13: Membuat Middleware Permission

Jalankan:

php artisan make:middleware PermissionMiddleware

Buka:

app/Http/Middleware/PermissionMiddleware.php

Isi:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class PermissionMiddleware
{
    public function handle(
        Request $request,
        Closure $next,
        string ...$permissions
    ): Response {
        $user = $request->user();

        if (! $user) {
            abort(401, 'Anda harus login terlebih dahulu.');
        }

        if (
            ! $user->hasRole('super-admin') &&
            ! $user->hasAnyPermission($permissions)
        ) {
            abort(403, 'Anda tidak memiliki izin untuk mengakses halaman ini.');
        }

        return $next($request);
    }
}

Pada contoh tersebut, pengguna dengan role super-admin diberikan akses ke seluruh halaman.

Role lainnya tetap diperiksa berdasarkan permission yang dimiliki.

Langkah 14: Mendaftarkan Middleware Laravel 11 ke Atas

Untuk Laravel 11, 12, dan 13, buka:

bootstrap/app.php

Tambahkan import:

use App\Http\Middleware\PermissionMiddleware;
use App\Http\Middleware\RoleMiddleware;
use Illuminate\Foundation\Configuration\Middleware;

Daftarkan alias:

->withMiddleware(function (Middleware $middleware): void {
    $middleware->alias([
        'role' => RoleMiddleware::class,
        'permission' => PermissionMiddleware::class,
    ]);
})

Laravel modern mendaftarkan alias middleware melalui bootstrap/app.php. Setelah alias dibuat, nama singkat middleware dapat diterapkan pada route.

Mendaftarkan Middleware pada Laravel 10

Untuk Laravel 10, buka:

app/Http/Kernel.php

Tambahkan:

protected $middlewareAliases = [
    // Middleware lainnya...

    'role' => \App\Http\Middleware\RoleMiddleware::class,
    'permission' => \App\Http\Middleware\PermissionMiddleware::class,
];

Sesuaikan metode pendaftaran dengan versi Laravel yang digunakan oleh project.

Langkah 15: Menggunakan Middleware Role pada Route

Contoh route yang hanya dapat diakses administrator:

Route::middleware([
    'auth',
    'role:super-admin,administrator',
])->group(function () {
    Route::get('/users', [UserController::class, 'index']);
});

Route tersebut hanya dapat diakses pengguna dengan role:

super-admin

atau:

administrator

Contoh pembatasan satu role:

Route::get('/settings', [SettingController::class, 'index'])
    ->middleware([
        'auth',
        'role:super-admin',
    ]);

Langkah 16: Menggunakan Middleware Permission

Contoh:

Route::get('/users', [UserController::class, 'index'])
    ->middleware([
        'auth',
        'permission:users.view',
    ]);

Menambahkan pengguna:

Route::post('/users', [UserController::class, 'store'])
    ->middleware([
        'auth',
        'permission:users.create',
    ]);

Mengubah pengguna:

Route::put('/users/{user}', [UserController::class, 'update'])
    ->middleware([
        'auth',
        'permission:users.update',
    ]);

Menghapus pengguna:

Route::delete('/users/{user}', [UserController::class, 'destroy'])
    ->middleware([
        'auth',
        'permission:users.delete',
    ]);

Beberapa permission dapat diberikan dalam satu route:

Route::get('/dashboard', DashboardController::class)
    ->middleware([
        'auth',
        'permission:dashboard.view,reports.view',
    ]);

Pada contoh middleware yang dibuat, pengguna cukup memiliki salah satu permission tersebut.

Langkah 17: Mengintegrasikan Permission dengan Gate

Agar permission dapat digunakan melalui @can, method can(), dan middleware bawaan Laravel, tambahkan pemeriksaan melalui Gate.

Buka:

app/Providers/AppServiceProvider.php

Tambahkan import:

use App\Models\User;
use Illuminate\Support\Facades\Gate;

Kemudian isi method boot():

public function boot(): void
{
    Gate::before(function (User $user, string $ability) {
        if ($user->hasRole('super-admin')) {
            return true;
        }

        if ($user->hasPermission($ability)) {
            return true;
        }

        return null;
    });
}

Gate::before() dijalankan sebelum pemeriksaan authorization lainnya. Jika callback mengembalikan nilai selain null, nilai tersebut digunakan sebagai hasil pemeriksaan. Mekanisme ini juga sering digunakan untuk memberikan seluruh ability kepada administrator tertentu.

Setelah konfigurasi tersebut, permission dapat diperiksa menggunakan:

auth()->user()->can('products.create');

Atau:

Gate::allows('products.update');

Langkah 18: Menggunakan Middleware can Bawaan Laravel

Setelah Gate dikonfigurasi, route dapat menggunakan middleware bawaan can.

Contoh:

Route::get('/products', [ProductController::class, 'index'])
    ->middleware([
        'auth',
        'can:products.view',
    ]);

Contoh menambahkan produk:

Route::post('/products', [ProductController::class, 'store'])
    ->middleware([
        'auth',
        'can:products.create',
    ]);

Laravel menyediakan middleware alias can secara otomatis. Jika pengguna tidak memiliki izin, middleware tersebut akan menghasilkan respons HTTP 403 sebelum request mencapai controller.

Langkah 19: Membatasi Tombol pada Blade

Tombol tidak hanya perlu dilindungi melalui tampilan. Route dan controller tetap harus memiliki pemeriksaan authorization.

Namun, menyembunyikan tombol dapat membuat antarmuka lebih mudah digunakan.

Menggunakan hasPermission

@if (auth()->user()->hasPermission('products.create'))
    <a href="{{ route('products.create') }}">
        Tambah Produk
    </a>
@endif

Menggunakan @can

Setelah Gate dikonfigurasi:

@can('products.create')
    <a href="{{ route('products.create') }}">
        Tambah Produk
    </a>
@endcan

Untuk tombol edit:

@can('products.update')
    <a href="{{ route('products.edit', $product) }}">
        Edit
    </a>
@endcan

Untuk tombol hapus:

@can('products.delete')
    <form
        action="{{ route('products.destroy', $product) }}"
        method="POST"
    >
        @csrf
        @method('DELETE')

        <button type="submit">
            Hapus
        </button>
    </form>
@endcan

Laravel menyediakan directive Blade @can dan @cannot untuk menampilkan bagian halaman berdasarkan hasil authorization pengguna.

Langkah 20: Memberikan Role kepada Pengguna

Contoh memberikan satu role:

$user->roles()->attach($roleId);

Mengganti seluruh role pengguna:

$user->roles()->sync([$roleId]);

Memberikan beberapa role:

$user->roles()->sync([
    $administratorRoleId,
    $managerRoleId,
]);

Menghapus satu role:

$user->roles()->detach($roleId);

Eloquent menyediakan attach, detach, dan sync untuk mengelola data pada tabel perantara relasi many-to-many. attach menambahkan relasi tanpa menghapus model utama, sedangkan detach menghapus hubungan pada tabel pivot.

Contoh Controller untuk Mengatur Role Pengguna

Contoh method update:

public function updateRoles(Request $request, User $user)
{
    $validated = $request->validate([
        'roles' => [
            'nullable',
            'array',
        ],
        'roles.*' => [
            'integer',
            'exists:roles,id',
        ],
    ]);

    $user->roles()->sync(
        $validated['roles'] ?? []
    );

    return back()->with(
        'success',
        'Role pengguna berhasil diperbarui.'
    );
}

Route-nya:

Route::put(
    '/users/{user}/roles',
    [UserController::class, 'updateRoles']
)->middleware([
    'auth',
    'permission:users.update',
]);

Contoh Controller untuk Mengatur Permission Role

public function updatePermissions(
    Request $request,
    Role $role
) {
    $validated = $request->validate([
        'permissions' => [
            'nullable',
            'array',
        ],
        'permissions.*' => [
            'integer',
            'exists:permissions,id',
        ],
    ]);

    $role->permissions()->sync(
        $validated['permissions'] ?? []
    );

    return back()->with(
        'success',
        'Permission role berhasil diperbarui.'
    );
}

Route:

Route::put(
    '/roles/{role}/permissions',
    [RoleController::class, 'updatePermissions']
)->middleware([
    'auth',
    'role:super-admin',
]);

Sebaiknya pengaturan role dan permission hanya dapat dilakukan oleh pengguna dengan kewenangan tertinggi.

Menampilkan Permission Berdasarkan Group

Data permission dapat diambil dan dikelompokkan berdasarkan kolom group:

$permissions = Permission::query()
    ->orderBy('group')
    ->orderBy('name')
    ->get()
    ->groupBy('group');

Kemudian pada Blade:

@foreach ($permissions as $group => $items)
    <div>
        <h3>{{ ucfirst($group) }}</h3>

        @foreach ($items as $permission)
            <label>
                <input
                    type="checkbox"
                    name="permissions[]"
                    value="{{ $permission->id }}"
                    @checked(
                        $role->permissions->contains(
                            $permission->id
                        )
                    )
                >

                {{ $permission->name }}
            </label>
        @endforeach
    </div>
@endforeach

Cara tersebut membuat halaman pengaturan lebih rapi karena permission pengguna, produk, transaksi, dan laporan tidak tercampur dalam satu daftar panjang.

Menggunakan Policy Bersama Permission

Untuk aplikasi yang memiliki aturan kepemilikan data, permission saja mungkin belum cukup.

Sebagai contoh:

• Pengguna mempunyai permission products.update.

• Namun, pengguna hanya boleh mengubah produk milik cabangnya.

Buat policy:

php artisan make:policy ProductPolicy --model=Product

Contoh:

<?php

namespace App\Policies;

use App\Models\Product;
use App\Models\User;

class ProductPolicy
{
    public function viewAny(User $user): bool
    {
        return $user->hasPermission('products.view');
    }

    public function create(User $user): bool
    {
        return $user->hasPermission('products.create');
    }

    public function update(
        User $user,
        Product $product
    ): bool {
        return $user->hasPermission('products.update')
            && $user->branch_id === $product->branch_id;
    }

    public function delete(
        User $user,
        Product $product
    ): bool {
        return $user->hasPermission('products.delete')
            && $user->branch_id === $product->branch_id;
    }
}

Dengan cara ini, permission menentukan tindakan umum, sedangkan policy memeriksa apakah pengguna boleh menjalankan tindakan tersebut pada data tertentu.

Optimasi Query Role dan Permission

Method hasPermission() melakukan query ke database setiap kali dipanggil.

Pada halaman dengan banyak menu atau tombol, pemeriksaan berulang dapat menghasilkan query yang cukup banyak.

Anda dapat memuat relasi sejak awal:

$user->loadMissing('roles.permissions');

Kemudian buat pemeriksaan berbasis collection:

public function hasPermission(string $permission): bool
{
    $this->loadMissing('roles.permissions');

    return $this->roles->contains(function ($role) use ($permission) {
        return $role->permissions->contains(
            'slug',
            $permission
        );
    });
}

Untuk aplikasi dengan jumlah pengguna dan permission besar, hasil permission juga dapat disimpan sementara menggunakan cache.

Namun, cache harus dihapus setiap kali role atau permission pengguna diperbarui.

Kesalahan yang Perlu Dihindari

Hanya Menyembunyikan Tombol

Menyembunyikan tombol pada Blade tidak cukup.

Pengguna masih dapat mencoba mengakses URL secara langsung. Karena itu, route atau controller tetap harus menggunakan middleware, Gate, atau Policy.

Memeriksa Nama Role

Hindari:

$user->hasRole('Administrator Utama');

Gunakan slug yang konsisten:

$user->hasRole('super-admin');

Menyimpan Role Langsung pada Session

Role dan permission dapat berubah saat pengguna masih login.

Gunakan database atau mekanisme cache yang dapat diperbarui dengan benar.

Memberikan Semua Akses kepada Role Biasa

Role dengan akses penuh sebaiknya dibatasi hanya untuk pengguna yang benar-benar membutuhkannya.

Tidak Membatasi Halaman Pengaturan Permission

Jika pengguna biasa dapat mengubah role-nya sendiri, sistem authorization kehilangan fungsinya.

Tidak Menggunakan Transaksi

Untuk proses perubahan role dan permission yang kompleks, gunakan transaksi database agar data tidak tersimpan sebagian ketika terjadi error.

Tidak Menghapus Cache

Jika permission disimpan dalam cache, hapus cache ketika terdapat perubahan role atau permission.

Kapan Sebaiknya Menggunakan Package?

Implementasi tanpa package cocok untuk:

1. Aplikasi dengan struktur hak akses sederhana.

2. Project yang membutuhkan kontrol penuh.

3. Jumlah role dan permission yang tidak terlalu kompleks.

4. Sistem internal perusahaan.

5. Aplikasi dengan kebutuhan authorization khusus.

Package dapat dipertimbangkan ketika aplikasi membutuhkan:

1. Permission cache yang siap digunakan.

2. Integrasi multi-guard.

3. Wildcard permission.

4. Pengelolaan role yang sangat kompleks.

5. Fitur team atau tenant.

6. Sistem permission yang digunakan di banyak project.

Menggunakan package atau membuat sendiri bukan persoalan mana yang selalu lebih baik. Pilih berdasarkan kebutuhan, kemampuan pemeliharaan, dan kompleksitas aplikasi.

Checklist Role dan Permission Laravel

Sebelum fitur digunakan, pastikan:

1. Tabel roles tersedia.

2. Tabel permissions tersedia.

3. Tabel role_user tersedia.

4. Tabel permission_role tersedia.

5. Model memiliki relasi belongsToMany.

6. Seeder berhasil dijalankan.

7. Pengguna sudah mempunyai role.

8. Role sudah mempunyai permission.

9. Middleware sudah dibuat.

10. Alias middleware sudah didaftarkan.

11. Route sudah dilindungi.

12. Tombol Blade menggunakan pemeriksaan permission.

13. Halaman pengaturan role hanya dapat diakses administrator.

14. Super administrator dilindungi dari perubahan yang tidak sah.

15. Policy digunakan jika terdapat aturan kepemilikan data.

16. Permission diuji menggunakan beberapa akun berbeda.

17. Cache authorization diperbarui setelah perubahan.

Pengembangan Sistem Hak Akses Bersama Ovla Media

Role dan permission merupakan bagian penting dalam aplikasi yang digunakan banyak pengguna.

Sistem hak akses dapat diterapkan pada:

1. Aplikasi Point of Sales.

2. Sistem inventory.

3. Sistem ERP.

4. Sistem CRM.

5. Aplikasi klinik.

6. Sistem gudang.

7. Dashboard monitoring.

8. Sistem sekolah.

9. Aplikasi koperasi.

10. Sistem informasi perusahaan.

11. Aplikasi pemerintahan.

12. Aplikasi bisnis custom.

Ovla Media menyediakan layanan pengembangan aplikasi Laravel dengan sistem role, permission, pembatasan cabang, audit aktivitas, dan hak akses yang dapat disesuaikan dengan alur kerja perusahaan.

Kesimpulan

Role digunakan untuk mengelompokkan pengguna berdasarkan jabatan atau tanggung jawab. Permission digunakan untuk menentukan tindakan yang dapat dilakukan oleh setiap role.

Sistem role dan permission Laravel tanpa package dapat dibuat menggunakan:

1. Migration.

2. Model Eloquent.

3. Relasi many-to-many.

4. Seeder.

5. Middleware.

6. Gate.

7. Policy.

8. Blade Directive.

Struktur utama yang digunakan adalah:

users
roles
permissions
role_user
permission_role

Pengguna dapat diperiksa berdasarkan role:

$user->hasRole('administrator');

Permission dapat diperiksa melalui:

$user->hasPermission('products.update');

Route dapat dilindungi menggunakan:

->middleware('permission:products.update')

Setelah diintegrasikan dengan Gate, tampilan dapat menggunakan:

@can('products.update')
    Tombol Edit
@endcan

Walaupun tombol telah disembunyikan, pemeriksaan pada route, middleware, controller, atau policy tetap wajib dilakukan.

Dengan struktur yang tepat, sistem hak akses dapat dikembangkan tanpa package tambahan dan tetap mudah disesuaikan dengan kebutuhan aplikasi.