Author: Vandy Ahmad Misry Ar Razy

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 Illuminate\Contracts\*. Contoh yang paling sering dipakai adalah type-hinting di constructor untuk decoupling:

<?php

namespace App\Services;

use Illuminate\Contracts\Cache\Repository as CacheContract;
use Illuminate\Contracts\Mail\Mailer 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 App\Contracts;

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

Buat beberapa implementasi:

<?php

namespace App\Services\Notifications;

use App\Contracts\NotificationChannel;
use Illuminate\Support\Facades\Mail;

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 App\Services\Notifications;

use App\Contracts\NotificationChannel;

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 App\Providers;

use App\Contracts\NotificationChannel;
use App\Services\Notifications\WhatsAppChannel;
use Illuminate\Support\ServiceProvider;

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 App\Http\Controllers;

use App\Contracts\NotificationChannel;

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