Kuasai Relasi Many-to-Many Laravel: Tutorial Lengkap

Dalam dunia pengembangan aplikasi web, seringkali kita dihadapkan pada skenario di mana satu entitas dapat memiliki hubungan dengan banyak entitas lain, dan sebaliknya. Contoh klasik adalah hubungan antara pengguna dan peran, produk dan kategori, atau artikel dan tag. Di Laravel, relasi Many-to-Many adalah kunci untuk memodelkan hubungan kompleks seperti ini.

Artikel ini akan memandu Anda, selangkah demi selangkah, untuk memahami, mengimplementasikan, dan memanfaatkan relasi Many-to-Many di Laravel dengan cara yang efektif, baik Anda seorang pemula maupun yang sudah berpengalaman.

Konsep Inti Relasi Many-to-Many

Relasi Many-to-Many terjadi ketika dua model memiliki banyak instance satu sama lain. Misalnya, seorang User dapat memiliki banyak Role (misalnya, Admin, Editor, Pengguna Biasa), dan satu Role dapat dimiliki oleh banyak User.

Untuk mengimplementasikan relasi ini, Laravel membutuhkan tabel perantara (sering disebut tabel pivot atau linking table). Tabel ini berfungsi untuk menyimpan hubungan antara kedua tabel yang berelasi. Tabel perantara ini akan memiliki dua kolom foreign key yang merujuk ke primary key dari kedua tabel utama.

Contoh: Jika kita memiliki model User dan Role, kita akan membutuhkan tabel role_user (atau user_roles) dengan kolom user_id dan role_id.

Langkah-langkah Implementasi Relasi Many-to-Many

Mari kita ilustrasikan dengan contoh umum: menghubungkan User dengan Role.

1. Struktur Database

Pastikan Anda memiliki tabel utama (users dan roles) dan tabel perantara (role_user).

Tabel users:

• id (PK, Increment)
• name
• email
• password
• created_at
• updated_at

Tabel roles:

• id (PK, Increment)
• name
• created_at
• updated_at

Tabel role_user (Tabel Pivot):

• user_id (FK ke users.id)
• role_id (FK ke roles.id)
• (Opsional) Kolom tambahan yang menyimpan informasi spesifik tentang hubungan, misalnya assigned_by.

Anda bisa membuat migrasi untuk tabel pivot ini:

php artisan make:migration create_role_user_table --create=role_user

Kemudian, edit file migrasi yang dihasilkan:

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateRoleUserTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('role_user', function (Blueprint $table) {
            $table->id(); // Jika Anda ingin kolom id terpisah di pivot table
            $table->foreignId('user_id')->constrained()->onDelete('cascade');
            $table->foreignId('role_id')->constrained()->onDelete('cascade');
            // $table->timestamps(); // Bisa juga ditambahkan jika perlu
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('role_user');
    }
}

Jalankan migrasi:

php artisan migrate

2. Definisi Model

Buat model untuk User dan Role jika belum ada.

// app/Models/User.php
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Sanctum\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;

    /**
     * The attributes that are mass assignable.
     *
     * @var array<int, string>
     */
    protected $fillable = [
        'name',
        'email',
        'password',
    ];

    /**
     * The attributes that should be hidden for serialization.
     *
     * @var array<int, string>
     */
    protected $hidden = [
        'password',
        'remember_token',
    ];

    /**
     * The attributes that should be cast.
     *
     * @var array<string, string>
     */
    protected $casts = [
        'email_verified_at' => 'datetime',
    ];

    /**
     * Get the roles associated with the user.
     */
    public function roles()
    {
        // Mendefinisikan relasi Many-to-Many ke model Role.
        // Parameter pertama adalah model target, kedua adalah nama tabel pivot.
        return $this->belongsToMany(Role::class);
    }
}

// app/Models/Role.php
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Role extends Model
{
    use HasFactory;

    protected $fillable = ['name'];

    /**
     * Get the users associated with the role.
     */
    public function users()
    {
        // Mendefinisikan relasi Many-to-Many ke model User.
        // Parameter pertama adalah model target, kedua adalah nama tabel pivot.
        return $this->belongsToMany(User::class);
    }
}

Catatan: Jika nama tabel pivot Anda tidak mengikuti konvensi penamaan Laravel (misalnya, role_user untuk User dan Role), Anda perlu menentukannya secara eksplisit dalam metode relasi: return $this->belongsToMany(Role::class, 'nama_tabel_pivot_anda');

3. Menggunakan Relasi

Sekarang, mari kita lihat bagaimana cara menggunakan relasi ini untuk mengambil dan menyimpan data.

Mengambil Data:

use App\Models\User;
use App\Models\Role;

// Mendapatkan semua pengguna dan role mereka
$users = User::with('roles')->get();
foreach ($users as $user) {
    echo "User: " . $user->name . "\n";
    foreach ($user->roles as $role) {
        echo "- " . $role->name . "\n";
    }
}

// Mendapatkan semua role dan pengguna yang memilikinya
$roles = Role::with('users')->get();
foreach ($roles as $role) {
    echo "Role: " . $role->name . "\n";
    foreach ($role->users as $user) {
        echo "- " . $user->name . "\n";
    }
}

// Mendapatkan role seorang pengguna tertentu
$user = User::find(1);
if ($user) {
    foreach ($user->roles as $role) {
        echo $user->name . " memiliki role: " . $role->name . "\n";
    }
}

// Mendapatkan pengguna yang memiliki role tertentu
$adminRole = Role::where('name', 'Admin')->first();
if ($adminRole) {
    foreach ($adminRole->users as $user) {
        echo "Pengguna dengan role Admin: " . $user->name . "\n";
    }
}

Menyimpan dan Memperbarui Data:

Menghubungkan atau melepaskan hubungan bisa dilakukan dengan beberapa cara.

• Menggunakan attach(): Untuk menambahkan relasi ke record yang ada.

  $user = User::find(1);
  $roleId = Role::where('name', 'Editor')->value('id');
  
  // Melampirkan role ke pengguna
  $user->roles()->attach($roleId);
  
  // Melampirkan beberapa role sekaligus
  $user->roles()->attach([2, 3]); // Melampirkan role dengan ID 2 dan 3
  

• Menggunakan sync(): Untuk mengganti semua relasi yang ada dengan sekumpulan relasi baru. Ini sangat berguna ketika Anda ingin memastikan hanya role tertentu yang terhubung dengan pengguna, menghapus yang lain jika tidak ada dalam daftar baru.

  $user = User::find(1);
  
  // Mengatur role pengguna menjadi 'Admin' dan 'Editor' saja
  // Jika pengguna sudah memiliki role lain, role tersebut akan dihapus.
  $user->roles()->sync([1, 2]); // Melampirkan role dengan ID 1 dan 2
  

• Menggunakan detach(): Untuk melepaskan relasi.

  $user = User::find(1);
  
  // Melepaskan role dengan ID 2 dari pengguna
  $user->roles()->detach(2);
  
  // Melepaskan semua role dari pengguna
  $user->roles()->detach();
  

• Menyimpan dengan Data Pivot: Jika tabel pivot Anda memiliki kolom tambahan, Anda dapat menyimpannya saat melampirkan.

  $user = User::find(1);
  $roleId = Role::where('name', 'Moderator')->value('id');
  
  // Menyimpan role dengan data pivot tambahan
  $user->roles()->attach($roleId, ['assigned_by' => 'System', 'created_at' => now()]);
  
  // Menggunakan sync dengan data pivot
  $user->roles()->sync([
      1 => ['assigned_by' => 'Admin'],
      2 => ['assigned_by' => 'Editor']
  ]);
  

  Untuk mengakses data pivot:

  $user = User::with('roles')->find(1);
  foreach ($user->roles as $role) {
      echo $user->name . " memiliki role " . $role->name . " yang ditugaskan oleh: " . $role->pivot->assigned_by . "\n";
  }
  

Tips Praktis & Fitur Lanjutan

1. Nama Tabel Pivot Otomatis: Jika Anda menamakan tabel pivot Anda sesuai konvensi Laravel (nama tabel diurutkan secara alfabetis dan dipisahkan oleh garis bawah, misal role_user), Anda tidak perlu menentukannya secara eksplisit di kode model.

2. belongsToMany dengan Parameter: $this->belongsToMany(RelatedModel::class, 'table_name', 'foreign_pivot_key', 'related_pivot_key');

   • RelatedModel::class: Model yang berelasi.
   • table_name: Nama tabel pivot Anda.
   • foreign_pivot_key: Kolom foreign key di tabel pivot yang merujuk ke model saat ini. Defaultnya adalah nama_model_saat_ini_id (misal user_id).
   • related_pivot_key: Kolom foreign key di tabel pivot yang merujuk ke RelatedModel. Defaultnya adalah nama_model_relasi_id (misal role_id).

3. Menggunakan withPivot(): Jika Anda perlu mengambil kolom tambahan dari tabel pivot selain kolom foreign key, gunakan withPivot() saat mendefinisikan relasi.

   public function roles()
   {
       return $this->belongsToMany(Role::class)->withPivot('assigned_by', 'created_at');
   }
   

   Ini akan membuat kolom assigned_by dan created_at tersedia di properti pivot dari objek Role yang terhubung.

4. Eager Loading dengan Data Pivot: Saat menggunakan with() untuk eager loading, Anda bisa sekaligus memuat kolom pivot. User::with('roles')->get(); Secara default, ini akan memuat user_id dan role_id di properti pivot. Untuk kolom tambahan, gunakan withPivot() seperti di atas.

5. Querying Pivot Data: Anda bisa melakukan query berdasarkan data di tabel pivot.

   // Mencari pengguna yang memiliki role 'Admin' dan ditugaskan oleh 'SuperAdmin'
   $users = User::whereHas('roles', function ($query) {
       $query->where('roles.name', 'Admin')
             ->wherePivot('assigned_by', 'SuperAdmin');
   })->get();
   

   Atau jika Anda ingin mengambil data pengguna dan data pivotnya:

   $usersWithAdminRoleAssignedBySuperAdmin = User::whereHas('roles', function ($query) {
       $query->where('roles.name', 'Admin')
             ->wherePivot('assigned_by', 'SuperAdmin');
   })->with(['roles' => function ($query) {
       $query->where('roles.name', 'Admin')->withPivot('assigned_by');
   }])->get();
   

6. belongsToMany Query Scope: Anda bisa menggunakan wherePivot(), wherePivotIn(), wherePivotNotIn(), wherePivotNull(), dan wherePivotNotNull() pada builder relasi.

7. Performance dengan load(): Anda bisa memuat relasi setelah model diambil, yang berguna jika Anda tidak tahu sebelumnya apakah relasi tersebut dibutuhkan.

   $user = User::find(1);
   // Hanya memuat relasi roles jika benar-benar dibutuhkan
   $user->load('roles');
   

Kesimpulan

Relasi Many-to-Many di Laravel adalah fitur yang sangat kuat untuk memodelkan hubungan data yang kompleks. Dengan pemahaman yang benar tentang tabel pivot, definisi model, dan metode-metode yang tersedia seperti attach(), sync(), dan detach(), Anda dapat membangun aplikasi yang lebih terstruktur dan efisien. Ingatlah untuk selalu mempertimbangkan performa, terutama saat berhadapan dengan dataset besar, dengan memanfaatkan eager loading dan teknik query yang tepat.

Semoga artikel ini memberikan Anda wawasan yang mendalam dan praktis untuk menguasai relasi Many-to-Many dalam proyek Laravel Anda!