Category: Tutorial

Artikel ini melanjutkan penjelasan konsep Observer di Laravel 12 dengan studi kasus implementasi lengkap: sistem audit trail dan auto-slug generation.

Studi Kasus 1: Auto-Slug Generation

Masalah umum: setiap kali artikel dibuat atau diupdate, slug harus di-generate dari title. Tanpa Observer, logika ini tersebar di berbagai controller.

Dengan Observer, cukup satu tempat:

<?php

namespace AppObservers;

use AppModelsArticle;
use IlluminateSupportStr;

class ArticleObserver
{
    public function creating(Article $article): void
    {
        $article->slug = $this->generateUniqueSlug($article->title);
    }

    public function updating(Article $article): void
    {
        if ($article->isDirty('title')) {
            $article->slug = $this->generateUniqueSlug($article->title, $article->id);
        }
    }

    private function generateUniqueSlug(string $title, ?int $excludeId = null): string
    {
        $slug  = Str::slug($title);
        $query = Article::where('slug', $slug);

        if ($excludeId) {
            $query->where('id', '!=', $excludeId);
        }

        if (!$query->exists()) {
            return $slug;
        }

        // Tambah angka kalau slug sudah ada
        $counter = 1;
        while (Article::where('slug', "{$slug}-{$counter}")
                      ->when($excludeId, fn ($q) => $q->where('id', '!=', $excludeId))
                      ->exists()) {
            $counter++;
        }

        return "{$slug}-{$counter}";
    }
}

Studi Kasus 2: Audit Trail Otomatis

Rekam semua perubahan pada model penting, berguna untuk compliance, debugging, atau fitur “lihat riwayat perubahan”:

<?php

namespace AppObservers;

use AppModelsArticle;
use AppModelsAuditLog;

class ArticleObserver
{
    public function created(Article $article): void
    {
        $this->log('created', $article, [], $article->getAttributes());
    }

    public function updated(Article $article): void
    {
        $this->log('updated', $article, $article->getOriginal(), $article->getChanges());
    }

    public function deleted(Article $article): void
    {
        $this->log('deleted', $article, $article->getAttributes(), []);
    }

    private function log(string $action, Article $article, array $old, array $new): void
    {
        AuditLog::create([
            'user_id'     => auth()->id(),
            'model_type'  => Article::class,
            'model_id'    => $article->id,
            'action'      => $action,
            'old_values'  => $old,
            'new_values'  => $new,
            'ip_address'  => request()->ip(),
        ]);
    }
}

Model AuditLog:

Schema::create('audit_logs', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->nullable()->constrained()->nullOnDelete();
    $table->string('model_type');
    $table->unsignedBigInteger('model_id');
    $table->string('action'); // created, updated, deleted
    $table->json('old_values')->nullable();
    $table->json('new_values')->nullable();
    $table->string('ip_address')->nullable();
    $table->timestamp('created_at');

    $table->index(['model_type', 'model_id']);
});

Studi Kasus 3: Cache Invalidation

Cache artikel halaman statis dan harus di-clear saat artikel berubah:

<?php

namespace AppObservers;

use AppModelsArticle;
use IlluminateSupportFacadesCache;

class ArticleObserver
{
    public function saved(Article $article): void
    {
        // Clear cache artikel individual
        Cache::forget("article:{$article->id}");
        Cache::forget("article:{$article->slug}");

        // Clear cache daftar artikel
        Cache::forget('articles:latest');
        Cache::forget("articles:category:{$article->category_id}");
    }

    public function deleted(Article $article): void
    {
        Cache::forget("article:{$article->id}");
        Cache::forget("article:{$article->slug}");
        Cache::forget('articles:latest');
    }
}

Studi Kasus 4: Observer dengan Multiple Models

Kalau beberapa model butuh audit trail yang sama, buat Observer yang reusable:

<?php

namespace AppObservers;

use AppModelsAuditLog;

class AuditableObserver
{
    public function created($model): void
    {
        AuditLog::create([
            'user_id'    => auth()->id(),
            'model_type' => get_class($model),
            'model_id'   => $model->id,
            'action'     => 'created',
            'new_values' => $model->getAttributes(),
        ]);
    }

    public function updated($model): void
    {
        AuditLog::create([
            'user_id'    => auth()->id(),
            'model_type' => get_class($model),
            'model_id'   => $model->id,
            'action'     => 'updated',
            'old_values' => $model->getOriginal(),
            'new_values' => $model->getChanges(),
        ]);
    }
}

Register ke beberapa model sekaligus:

// Di AppServiceProvider
Article::observe(AuditableObserver::class);
Product::observe(AuditableObserver::class);
Order::observe(AuditableObserver::class);

Bypass Observer saat Seeding

<?php

namespace DatabaseSeeders;

use AppModelsArticle;

class ArticleSeeder extends Seeder
{
    public function run(): void
    {
        // Bypass observer agar tidak trigger audit trail saat seeding
        Article::withoutObservers(function () {
            Article::factory(100)->create();
        });
    }
}

Baca Juga

• Apa Itu Observer di Laravel 12 dan Kapan Menggunakannya
• Apa Itu Event dan Listener di Laravel 12

Butuh tim yang bantu implementasi arsitektur yang clean di aplikasi Laravel? Lihat layanan pengembangan aplikasi kami.

Baca Juga

• Cara Membuat Custom Artisan Command di Laravel 12
• Cara Instalasi Laravel Volt di Laravel 12
• Keunggulan Laravel Volt

Artikel ini melanjutkan penjelasan konsep Policy dan Gate di Laravel 12 dengan studi kasus implementasi lengkap: sistem manajemen konten dengan beberapa level akses.

Studi Kasus: Sistem CMS dengan Multi-Role

Skenario: aplikasi CMS dengan role admin, editor, dan author. Aturannya:

• Admin bisa lakukan semua aksi di artikel mana saja
• Editor bisa buat, edit, dan publish artikel mana saja
• Author hanya bisa buat dan edit artikel miliknya sendiri

Setup Model User dengan Role

<?php

namespace App\Models;

use Illuminate\Foundation\Auth\User as Authenticatable;

class User extends Authenticatable
{
    protected $fillable = ['name', 'email', 'password', 'role'];

    public function isAdmin(): bool
    {
        return $this->role === 'admin';
    }

    public function isEditor(): bool
    {
        return in_array($this->role, ['admin', 'editor']);
    }
}

ArticlePolicy Lengkap

<?php

namespace App\Policies;

use App\Models\Article;
use App\Models\User;

class ArticlePolicy
{
    // Ini dijalankan sebelum semua method lain
    // Return true = admin bypass semua check
    public function before(User $user, string $ability): ?bool
    {
        if ($user->isAdmin()) {
            return true;
        }

        return null; // null = lanjut ke check berikutnya
    }

    public function viewAny(?User $user): bool
    {
        // Semua orang bisa lihat daftar artikel yang published
        return true;
    }

    public function view(?User $user, Article $article): bool
    {
        if ($article->status === 'published') {
            return true;
        }

        // Draft hanya bisa dilihat pemilik atau editor
        return $user && ($article->user_id === $user->id || $user->isEditor());
    }

    public function create(User $user): bool
    {
        return $user->hasVerifiedEmail();
    }

    public function update(User $user, Article $article): bool
    {
        // Editor bisa edit semua, author hanya punya sendiri
        return $user->isEditor() || $article->user_id === $user->id;
    }

    public function delete(User $user, Article $article): bool
    {
        // Hanya admin (via before()) atau pemilik artikel
        return $article->user_id === $user->id;
    }

    public function publish(User $user, Article $article): bool
    {
        // Hanya editor ke atas yang bisa publish
        return $user->isEditor();
    }

    public function restore(User $user, Article $article): bool
    {
        return $user->isEditor() || $article->user_id === $user->id;
    }
}

Menggunakan Policy di Controller

<?php

namespace App\Http\Controllers;

use App\Models\Article;
use App\Http\Requests\StoreArticleRequest;

class ArticleController extends Controller
{
    public function index()
    {
        $this->authorize('viewAny', Article::class);

        $articles = Article::with('author')
                           ->when(!auth()->user()?->isEditor(), fn ($q) =>
                               $q->where('status', 'published')
                                 ->orWhere('user_id', auth()->id())
                           )
                           ->paginate(15);

        return view('articles.index', compact('articles'));
    }

    public function edit(Article $article)
    {
        $this->authorize('update', $article);
        return view('articles.edit', compact('article'));
    }

    public function destroy(Article $article)
    {
        $this->authorize('delete', $article);
        $article->delete();
        return redirect()->route('articles.index')
                         ->with('success', 'Artikel dihapus.');
    }

    public function publish(Article $article)
    {
        $this->authorize('publish', $article);
        $article->update(['status' => 'published', 'published_at' => now()]);
        return back()->with('success', 'Artikel dipublish.');
    }
}

Policy di Blade Template

@foreach ($articles as $article)
    <div>
        <h2>{{ $article->title }}</h2>

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

        @can('publish', $article)
            @if($article->status === 'draft')
                <form action="{{ route('articles.publish', $article) }}" method="POST">
                    @csrf @method('PATCH')
                    <button>Publish</button>
                </form>
            @endif
        @endcan

        @can('delete', $article)
            <form action="{{ route('articles.destroy', $article) }}" method="POST">
                @csrf @method('DELETE')
                <button>Hapus</button>
            </form>
        @endcan
    </div>
@endforeach

Gate untuk Aksi Global

Untuk akses fitur yang tidak terkait model tertentu, pakai Gate:

// Di AppServiceProvider
Gate::define('access-analytics', fn (User $user) => $user->isEditor());
Gate::define('export-all-data',  fn (User $user) => $user->isAdmin());

// Di controller
Gate::authorize('access-analytics');
return view('analytics.dashboard');

// Di Blade
@can('access-analytics')
    <a href="/analytics">Analytics</a>
@endcan

Baca Juga

• Apa Itu Policy dan Gate di Laravel 12: Konsep dan Perbedaannya
• Apa Itu Observer di Laravel 12

Butuh tim yang bantu implementasi sistem otorisasi yang tepat untuk aplikasi Laravel Anda? Lihat layanan pengembangan aplikasi kami.

Baca Juga

• Cara Membuat Custom Artisan Command di Laravel 12
• Cara Instalasi Laravel Volt di Laravel 12
• Keunggulan Laravel Volt

Artikel sebelumnya membahas konsep Concurrency di Laravel 12. Artikel ini fokus pada implementasi: studi kasus nyata bagaimana Concurrency bisa mempercepat aplikasi secara signifikan.

Studi Kasus 1: Dashboard dengan Banyak Data Source

Dashboard admin yang butuh data dari beberapa tabel berbeda. Ini biasanya jadi bottleneck karena diquery satu per satu.

Sebelum (sequential — sekitar 800ms):

public function dashboard()
{
    $totalOrders    = Order::thisMonth()->count();          // ~200ms
    $totalRevenue   = Order::thisMonth()->sum('total');     // ~200ms
    $pendingOrders  = Order::where('status', 'pending')->count(); // ~150ms
    $newCustomers   = User::thisMonth()->count();           // ~150ms
    $topProducts    = Product::topSelling(5)->get();       // ~100ms

    return view('dashboard', compact(...));
}

Sesudah (paralel — sekitar 200ms):

use IlluminateSupportFacadesConcurrency;

public function dashboard()
{
    [$totalOrders, $totalRevenue, $pendingOrders, $newCustomers, $topProducts] =
        Concurrency::run([
            fn() => Order::thisMonth()->count(),
            fn() => Order::thisMonth()->sum('total'),
            fn() => Order::where('status', 'pending')->count(),
            fn() => User::thisMonth()->count(),
            fn() => Product::topSelling(5)->get(),
        ]);

    return view('dashboard', compact(
        'totalOrders', 'totalRevenue', 'pendingOrders', 'newCustomers', 'topProducts'
    ));
}

Studi Kasus 2: Multiple API Calls

Halaman product detail yang butuh data dari beberapa API eksternal:

use IlluminateSupportFacadesConcurrency;

public function productDetail(Product $product): View
{
    [$reviews, $stock, $shippingOptions] = Concurrency::run([
        fn() => $this->reviewApi->getProductReviews($product->id),    // API 1
        fn() => $this->inventoryApi->getStock($product->sku),         // API 2
        fn() => $this->shippingApi->getOptions($product->weight),     // API 3
    ]);

    return view('products.detail', compact('product', 'reviews', 'stock', 'shippingOptions'));
}

Kalau masing-masing API butuh 500ms, tanpa concurrency total 1.5 detik. Dengan concurrency, cukup ~500ms.

Studi Kasus 3: Defer untuk Aksi Non-Blocking

User logout — beberapa aksi perlu terjadi tapi tidak perlu selesai sebelum response dikirim:

use IlluminateSupportFacadesConcurrency;

public function logout(Request $request): RedirectResponse
{
    $user = $request->user();

    Auth::logout();
    $request->session()->invalidate();
    $request->session()->regenerateToken();

    // Jalankan setelah response dikirim
    Concurrency::defer([
        fn() => $this->activityLog->record($user, 'logout'),
        fn() => $this->deviceTokenService->revokeAll($user),
        fn() => $this->sessionCleanup->cleanup($user),
    ]);

    return redirect('/');
}

Studi Kasus 4: Generate Laporan Parallel

Generate beberapa bagian laporan sekaligus lalu gabungkan:

public function generateAnnualReport(int $year): array
{
    [$salesData, $customerData, $productData, $regionData] = Concurrency::run([
        fn() => $this->salesReport->compile($year),
        fn() => $this->customerReport->compile($year),
        fn() => $this->productReport->compile($year),
        fn() => $this->regionReport->compile($year),
    ]);

    return [
        'year'     => $year,
        'sales'    => $salesData,
        'customers' => $customerData,
        'products' => $productData,
        'regions'  => $regionData,
        'generated_at' => now()->toIso8601String(),
    ];
}

Error Handling di Concurrency

Kalau salah satu closure melempar exception, Concurrency akan meneruskan exception tersebut:

use IlluminateSupportFacadesConcurrency;

try {
    [$data1, $data2] = Concurrency::run([
        fn() => riskyApiCall(),
        fn() => anotherApiCall(),
    ]);
} catch (Exception $e) {
    // Handle error — biasanya fallback ke data cached atau default
    Log::warning("Concurrency error: {$e->getMessage()}");
    [$data1, $data2] = [getFromCache('data1'), getFromCache('data2')];
}

Kapan Tidak Pakai Concurrency

Jangan pakai untuk operasi yang sangat cepat. Overhead membuka child process (~50-100ms) lebih mahal dari manfaatnya kalau setiap closure selesai dalam 5ms.

Gunakan untuk operasi yang masing-masing butuh 100ms ke atas, terutama I/O seperti HTTP request, query database, atau baca file besar.

Baca Juga

• Apa Itu Concurrency di Laravel 12 dan Kapan Menggunakannya
• Tutorial Job Batching di Laravel 12

Butuh tim yang bantu optimasi performa aplikasi Laravel Anda? Lihat layanan pengembangan aplikasi kami.

Baca Juga

• Cara Membuat Custom Artisan Command di Laravel 12
• Cara Instalasi Laravel Volt di Laravel 12
• Keunggulan Laravel Volt

Kalau Anda sudah membaca artikel tentang apa itu Contract di Laravel 12, artikel ini melanjutkannya dengan contoh penggunaan nyata: bagaimana membuat implementasi Contract sendiri dan kapan ini berguna dalam proyek.

Menggunakan Contract Bawaan Laravel

Contract bawaan Laravel ada di namespace IlluminateContracts*. Contoh yang paling sering dipakai adalah type-hinting di constructor untuk decoupling:

<?php

namespace AppServices;

use IlluminateContractsCacheRepository as CacheContract;
use IlluminateContractsMailMailer as MailerContract;

class NotificationService
{
    public function __construct(
        private CacheContract  $cache,
        private MailerContract $mailer,
    ) {}

    public function sendIfNotSent(string $userId, string $template): void
    {
        $cacheKey = "notification:{$userId}:{$template}";

        if ($this->cache->has($cacheKey)) {
            return; // Sudah dikirim
        }

        $this->mailer->send($template, [], fn ($m) => $m->to($userId));
        $this->cache->put($cacheKey, true, now()->addDay());
    }
}

Service ini bisa ditest dengan mudah — tinggal inject mock CacheContract dan MailerContract.

Membuat Contract Sendiri

Studi kasus: aplikasi yang butuh fitur kirim notifikasi ke berbagai channel (email, SMS, WhatsApp). Dengan Contract, kita bisa ganti implementasi tanpa mengubah kode yang memakainya.

Buat Contract interface di app/Contracts/NotificationChannel.php:

<?php

namespace AppContracts;

interface NotificationChannel
{
    public function send(string $recipient, string $message): bool;
    public function isAvailable(): bool;
}

Buat beberapa implementasi:

<?php

namespace AppServicesNotifications;

use AppContractsNotificationChannel;
use IlluminateSupportFacadesMail;

class EmailChannel implements NotificationChannel
{
    public function send(string $recipient, string $message): bool
    {
        try {
            Mail::raw($message, fn ($m) => $m->to($recipient));
            return true;
        } catch (Exception $e) {
            return false;
        }
    }

    public function isAvailable(): bool
    {
        return config('mail.default') !== null;
    }
}

<?php

namespace AppServicesNotifications;

use AppContractsNotificationChannel;

class WhatsAppChannel implements NotificationChannel
{
    public function __construct(
        private WhatsAppApiClient $client
    ) {}

    public function send(string $recipient, string $message): bool
    {
        return $this->client->sendMessage($recipient, $message);
    }

    public function isAvailable(): bool
    {
        return !empty(config('services.whatsapp.token'));
    }
}

Bind Contract ke Implementasi di Service Provider

<?php

namespace AppProviders;

use AppContractsNotificationChannel;
use AppServicesNotificationsWhatsAppChannel;
use IlluminateSupportServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        // Bind default implementation
        $this->app->bind(NotificationChannel::class, WhatsAppChannel::class);
    }
}

Sekarang di mana saja Anda type-hint NotificationChannel, Laravel otomatis inject WhatsAppChannel:

<?php

namespace AppHttpControllers;

use AppContractsNotificationChannel;

class AlertController extends Controller
{
    public function __construct(
        private NotificationChannel $channel
    ) {}

    public function send(Request $request): Response
    {
        $sent = $this->channel->send(
            $request->recipient,
            $request->message
        );

        return response()->json(['success' => $sent]);
    }
}

Manfaat: Mudah Ganti Implementasi

Kalau besok ingin switch dari WhatsApp ke SMS, cukup ganti binding di service provider:

$this->app->bind(NotificationChannel::class, SmsChannel::class);

Controller dan semua kode yang pakai NotificationChannel tidak perlu diubah sama sekali.

Contoh: Kontekstual Binding

Kalau perlu inject implementasi berbeda di class berbeda:

$this->app->when(AlertController::class)
          ->needs(NotificationChannel::class)
          ->give(WhatsAppChannel::class);

$this->app->when(ReportController::class)
          ->needs(NotificationChannel::class)
          ->give(EmailChannel::class);

Baca Juga

• Apa Itu Contract di Laravel 12 dan Bagaimana Cara Kerjanya
• Apa Itu Observer di Laravel 12 dan Kapan Menggunakannya

Mau tim yang bantu bangun arsitektur aplikasi Laravel yang scalable? Lihat layanan pengembangan aplikasi kami.

Baca Juga

• Cara Membuat Custom Artisan Command di Laravel 12
• Cara Instalasi Laravel Volt di Laravel 12
• Keunggulan Laravel Volt

Kalau Event dan Listener cocok untuk “sesuatu terjadi di aplikasi, beri tahu komponen lain”, Observer punya fokus berbeda: “ketika Eloquent model berubah, jalankan kode ini.”

Artikel ini menjelaskan apa itu Observer di Laravel 12, perbedaannya dengan Event Listener, dan kapan sebaiknya dipakai.

Observer Adalah: Pengertian Singkat

Secara bahasa, observer adalah pengamat, yaitu pihak yang memperhatikan sesuatu lalu bereaksi ketika ada perubahan. Dalam pemrograman, istilah ini berasal dari observer pattern: sebuah pola desain di mana satu objek (yang diamati) memberi tahu objek-objek lain (para observer) setiap kali keadaannya berubah, sehingga mereka bisa menjalankan tugasnya masing-masing tanpa saling terikat erat.

Contoh sederhananya notifikasi: ketika status pesanan berubah menjadi “dikirim”, bagian yang mengirim email dan bagian yang mencatat riwayat ikut bereaksi tanpa kode pengubah status perlu tahu siapa saja yang mendengarkan. Laravel menerapkan pola ini khusus untuk model database lewat fitur Observer.

Apa Itu Observer di Laravel?

Observer adalah kelas yang merespons event lifecycle Eloquent model: saat model dibuat, diupdate, dihapus, dll. Daripada pasang listener di banyak tempat, Observer mengumpulkan semua hook untuk satu model di satu kelas.

Event lifecycle yang bisa di-observe:

• creating / created
• updating / updated
• saving / saved
• deleting / deleted
• restoring / restored (untuk soft deletes)
• forceDeleting / forceDeleted

Membuat Observer

php artisan make:observer ArticleObserver --model=Article

File dibuat di app/Observers/ArticleObserver.php:

<?php

namespace AppObservers;

use AppModelsArticle;
use IlluminateSupportStr;

class ArticleObserver
{
    public function creating(Article $article): void
    {
        // Auto-generate slug sebelum disimpan
        if (empty($article->slug)) {
            $article->slug = Str::slug($article->title);
        }
    }

    public function created(Article $article): void
    {
        // Kirim notifikasi ke admin
        cache()->forget('articles.count');
    }

    public function updating(Article $article): void
    {
        // Update slug kalau title berubah
        if ($article->isDirty('title')) {
            $article->slug = Str::slug($article->title);
        }
    }

    public function deleting(Article $article): void
    {
        // Hapus gambar terkait sebelum artikel dihapus
        $article->images()->each(fn ($img) => $img->delete());
    }
}

Registrasi Observer

Di app/Providers/AppServiceProvider.php:

<?php

namespace AppProviders;

use AppModelsArticle;
use AppObserversArticleObserver;
use IlluminateSupportServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        Article::observe(ArticleObserver::class);
    }
}

Atau bisa dengan attribute di model (Laravel 12):

use AppObserversArticleObserver;
use IlluminateDatabaseEloquentAttributesObservedBy;

#[ObservedBy([ArticleObserver::class])]
class Article extends Model
{
    // ...
}

Observer vs Event Listener: Kapan Pakai Yang Mana?

Menonaktifkan Observer Sementara

Berguna saat import data massal, agar Observer tidak dipanggil ribuan kali:

// Import tanpa trigger Observer
Article::withoutObservers(function () {
    foreach ($rows as $row) {
        Article::create($row);
    }
});

// Atau nonaktifkan event model seluruhnya
Article::unsetEventDispatcher();

Setelah import selesai, event otomatis aktif kembali.

Baca Juga

• Contoh Implementasi Observer di Laravel 12: Studi Kasus Lengkap
• Apa Itu Event dan Listener di Laravel 12

Mau tim yang bantu setup arsitektur model-driven di aplikasi Laravel Anda? Lihat layanan pengembangan aplikasi kami.