Category: Tutorial

  • Contoh Penggunaan Contract di Laravel 12: Implementasi dan Binding

    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

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

    Baca Juga

  • Apa Itu Observer di Laravel 12 dan Kapan Menggunakannya

    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.

    Apa Itu Observer?

    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?

    Kondisi Pilihan
    Hook spesifik ke satu Eloquent model Observer
    Aksi yang dipicu dari banyak model berbeda Event Listener
    Logika bisnis yang tidak terkait model Eloquent Event Listener
    Semua hook untuk satu model ingin dikumpulkan di satu tempat Observer

    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

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

  • Apa Itu Event dan Listener di Laravel 12: Arsitektur Event-Driven

    Salah satu ciri arsitektur Laravel yang baik: ketika sesuatu terjadi di aplikasi, komponen lain bisa “mendengarkan” dan merespons, tanpa si pengirim perlu tahu siapa yang merespons.

    Itulah fungsi Event dan Listener di Laravel. Artikel ini menjelaskan cara kerjanya dan bagaimana implementasinya dengan contoh nyata.

    Konsep Event dan Listener

    Event adalah kejadian yang terjadi di aplikasi: user mendaftar, order diproses, pembayaran berhasil. Listener adalah kode yang merespons kejadian tersebut.

    Satu event bisa punya beberapa listener. Misalnya saat UserRegistered:

    • Listener 1: kirim email selamat datang
    • Listener 2: create profil default
    • Listener 3: sync ke CRM

    Controller yang trigger event tidak perlu tahu ada 3 listener di belakang. Ini yang membuat kode lebih modular.

    Membuat Event dan Listener

    php artisan make:event UserRegistered
    php artisan make:listener SendWelcomeEmail --event=UserRegistered
    php artisan make:listener CreateDefaultProfile --event=UserRegistered

    Kelas event (app/Events/UserRegistered.php):

    <?php
    
    namespace AppEvents;
    
    use AppModelsUser;
    use IlluminateFoundationEventsDispatchable;
    use IlluminateQueueSerializesModels;
    
    class UserRegistered
    {
        use Dispatchable, SerializesModels;
    
        public function __construct(
            public readonly User $user
        ) {}
    }

    Listener (app/Listeners/SendWelcomeEmail.php):

    <?php
    
    namespace AppListeners;
    
    use AppEventsUserRegistered;
    use AppMailWelcomeMail;
    use IlluminateContractsQueueShouldQueue;
    use IlluminateSupportFacadesMail;
    
    class SendWelcomeEmail implements ShouldQueue
    {
        public function handle(UserRegistered $event): void
        {
            Mail::to($event->user)->send(new WelcomeMail($event->user));
        }
    }

    Implement ShouldQueue agar listener dijalankan di background queue, tidak memperlambat proses registrasi.

    Registrasi Event dan Listener

    Di Laravel 12 (dan sejak Laravel 11), cukup tambahkan di app/Providers/AppServiceProvider.php:

    <?php
    
    namespace AppProviders;
    
    use AppEventsUserRegistered;
    use AppListenersSendWelcomeEmail;
    use AppListenersCreateDefaultProfile;
    use IlluminateSupportFacadesEvent;
    use IlluminateSupportServiceProvider;
    
    class AppServiceProvider extends ServiceProvider
    {
        public function boot(): void
        {
            Event::listen(UserRegistered::class, SendWelcomeEmail::class);
            Event::listen(UserRegistered::class, CreateDefaultProfile::class);
        }
    }

    Laravel juga mendukung auto-discovery. Kalau nama listener mengikuti konvensi, registrasi manual tidak diperlukan. Tapi registrasi manual lebih eksplisit dan lebih mudah di-trace.

    Dispatch Event

    // Di controller atau service
    use AppEventsUserRegistered;
    
    $user = User::create($validated);
    
    UserRegistered::dispatch($user);
    
    // Atau lewat helper
    event(new UserRegistered($user));

    Listener Synchronous vs Queued

    Kalau listener implement ShouldQueue, dijalankan di background. Kalau tidak, dijalankan langsung (synchronous) sebelum response dikirim.

    Kapan pakai synchronous:

    • Listener yang hasilnya dibutuhkan sebelum response dikirim
    • Operasi yang sangat cepat (kurang dari 10ms)

    Kapan pakai queued:

    • Kirim email, notifikasi, sync ke API eksternal
    • Semua operasi yang tidak perlu hasilnya sekarang

    Wildcard Listener

    Kalau perlu listen ke banyak event sekaligus (misalnya untuk logging):

    Event::listen('AppEvents*', function (string $eventName, array $data) {
        Log::info("Event: {$eventName}", $data);
    });

    Baca Juga

    Butuh tim untuk merancang arsitektur event-driven di aplikasi Laravel Anda? Lihat layanan pengembangan aplikasi kami.

  • Apa Itu Policy dan Gate di Laravel 12: Sistem Otorisasi yang Tepat

    Bayangkan ada dua pertanyaan berbeda soal keamanan di aplikasi Anda: “Apakah user ini boleh edit artikel?” dan “Apakah user yang login adalah editor?”

    Pertanyaan pertama terkait Policy: otorisasi berdasarkan resource. Pertanyaan kedua terkait Gate: otorisasi berdasarkan kemampuan/role. Keduanya bagian dari sistem Authorization di Laravel.

    Apa Itu Gate?

    Gate adalah cara mendefinisikan otorisasi berbasis kemampuan (ability) secara sederhana, biasanya untuk aksi yang tidak terkait langsung dengan model tertentu.

    Definisikan Gate di app/Providers/AppServiceProvider.php:

    <?php
    
    namespace AppProviders;
    
    use AppModelsUser;
    use IlluminateSupportFacadesGate;
    use IlluminateSupportServiceProvider;
    
    class AppServiceProvider extends ServiceProvider
    {
        public function boot(): void
        {
            Gate::define('access-admin-panel', function (User $user) {
                return $user->role === 'admin';
            });
    
            Gate::define('manage-settings', function (User $user) {
                return in_array($user->role, ['admin', 'superadmin']);
            });
        }
    }

    Gunakan di controller atau view:

    // Di controller
    if (Gate::denies('access-admin-panel')) {
        abort(403);
    }
    
    // Dengan authorize (auto-throw 403 jika gagal)
    Gate::authorize('access-admin-panel');
    
    // Di Blade
    @can('access-admin-panel')
        <a href="/admin">Admin Panel</a>
    @endcan

    Apa Itu Policy?

    Policy adalah kelas yang mengelompokkan logika otorisasi untuk satu model. Cocok untuk otorisasi seperti “siapa yang boleh edit, hapus, atau lihat resource ini?”

    php artisan make:policy ArticlePolicy --model=Article

    File dibuat di app/Policies/ArticlePolicy.php:

    <?php
    
    namespace AppPolicies;
    
    use AppModelsArticle;
    use AppModelsUser;
    
    class ArticlePolicy
    {
        public function viewAny(User $user): bool
        {
            return true; // Semua user bisa lihat daftar artikel
        }
    
        public function view(User $user, Article $article): bool
        {
            // Bisa lihat kalau published, atau kalau milik sendiri
            return $article->status === 'published' || $article->user_id === $user->id;
        }
    
        public function create(User $user): bool
        {
            return $user->hasVerifiedEmail();
        }
    
        public function update(User $user, Article $article): bool
        {
            // Hanya pemilik yang bisa edit
            return $article->user_id === $user->id;
        }
    
        public function delete(User $user, Article $article): bool
        {
            // Pemilik dan admin bisa hapus
            return $article->user_id === $user->id || $user->role === 'admin';
        }
    }

    Registrasi Policy

    Di Laravel 12, policy otomatis ditemukan (auto-discovery) kalau struktur folder sesuai konvensi. Tapi Anda juga bisa register manual di AppServiceProvider:

    use AppModelsArticle;
    use AppPoliciesArticlePolicy;
    use IlluminateSupportFacadesGate;
    
    Gate::policy(Article::class, ArticlePolicy::class);

    Menggunakan Policy

    // Di controller
    public function edit(Article $article)
    {
        $this->authorize('update', $article); // Throw 403 kalau tidak bisa
    
        return view('articles.edit', compact('article'));
    }
    
    // Cek tanpa throw exception
    if ($request->user()->can('update', $article)) {
        // boleh lanjut
    }
    
    // Di Blade
    @can('update', $article)
        <a href="{{ route('articles.edit', $article) }}">Edit</a>
    @endcan
    
    @cannot('delete', $article)
        <p>Anda tidak bisa hapus artikel ini.</p>
    @endcannot

    Gate vs Policy: Kapan Pakai Yang Mana?

    Kondisi Gunakan
    Otorisasi terkait satu model (Article, Order, dll.) Policy
    Otorisasi berdasarkan role/kemampuan global Gate
    Aturan sederhana yang tidak butuh kelas terpisah Gate
    Banyak aturan berbeda untuk satu model Policy

    Baca Juga

    Butuh tim yang bantu implementasi sistem otorisasi yang aman di aplikasi Laravel? Lihat layanan pengembangan aplikasi kami.

  • Cara Membuat Custom Artisan Command di Laravel 12

    Artisan bawaan Laravel sudah mencakup banyak kebutuhan. Tapi kadang Anda butuh command yang spesifik untuk proyek Anda, misalnya generate laporan harian, kirim email batch, atau sync data dari API eksternal.

    Di sinilah custom Artisan command berguna. Artikel ini menunjukkan cara membuat, mengatur parameter, dan menjalankan scheduled command di Laravel 12.

    Membuat Custom Command

    Gunakan Artisan untuk generate skeleton command:

    php artisan make:command SendDailyReport

    File dibuat di app/Console/Commands/SendDailyReport.php:

    <?php
    
    namespace AppConsoleCommands;
    
    use IlluminateConsoleCommand;
    
    class SendDailyReport extends Command
    {
        protected $signature = 'report:daily';
        protected $description = 'Send daily sales report to managers';
    
        public function handle(): int
        {
            // logika command di sini
    
            return Command::SUCCESS;
        }
    }

    Jalankan:

    php artisan report:daily

    Menambahkan Argumen dan Opsi

    Command yang berguna biasanya butuh input. Ada dua jenis: argumen (wajib) dan opsi (opsional dengan --).

    protected $signature = 'report:send
                            {type : Tipe laporan: sales atau inventory}
                            {--date= : Tanggal laporan (default: hari ini)}
                            {--dry-run : Simulasi tanpa kirim email}';
    

    Cara mengakses di dalam handle():

    public function handle(): int
    {
        $type    = $this->argument('type');
        $date    = $this->option('date') ?? now()->toDateString();
        $dryRun  = $this->option('dry-run');
    
        $this->info("Membuat laporan {$type} untuk tanggal {$date}...");
    
        if ($dryRun) {
            $this->warn('Mode dry-run: email tidak akan dikirim.');
        }
    
        // proses laporan...
    
        $this->info('Selesai.');
        return Command::SUCCESS;
    }

    Contoh penggunaan:

    php artisan report:send sales
    php artisan report:send sales --date=2025-04-01
    php artisan report:send inventory --dry-run

    Output yang Informatif

    Artisan menyediakan beberapa helper untuk output yang bersih:

    $this->info('Pesan biasa');      // hijau
    $this->error('Ada error!');     // merah
    $this->warn('Perhatian');       // kuning
    $this->line('Teks biasa');      // putih
    $this->comment('// komentar'); // abu-abu
    
    // Progress bar untuk proses batch
    $users = User::all();
    $bar   = $this->output->createProgressBar(count($users));
    $bar->start();
    
    foreach ($users as $user) {
        // proses
        $bar->advance();
    }
    
    $bar->finish();

    Dependency Injection di Custom Command

    Inject service lewat constructor, sama seperti controller:

    <?php
    
    namespace AppConsoleCommands;
    
    use AppServicesReportService;
    use AppServicesMailService;
    use IlluminateConsoleCommand;
    
    class SendDailyReport extends Command
    {
        protected $signature = 'report:daily {--date=}';
        protected $description = 'Send daily report via email';
    
        public function __construct(
            private ReportService $reportService,
            private MailService   $mailService,
        ) {
            parent::__construct();
        }
    
        public function handle(): int
        {
            $date   = $this->option('date') ?? now()->toDateString();
            $report = $this->reportService->generate($date);
    
            if ($report->isEmpty()) {
                $this->warn("Tidak ada data untuk tanggal {$date}.");
                return Command::SUCCESS;
            }
    
            $this->mailService->sendReport($report);
            $this->info("Laporan {$date} berhasil dikirim ke " . $report->recipientCount() . " penerima.");
    
            return Command::SUCCESS;
        }
    }

    Menjadwalkan Command Otomatis

    Di Laravel 12, jadwal command diatur di routes/console.php — bukan lagi di app/Console/Kernel.php:

    <?php
    
    use IlluminateSupportFacadesSchedule;
    
    // Kirim laporan setiap hari jam 7 pagi
    Schedule::command('report:daily')->dailyAt('07:00');
    
    // Bersihkan log setiap minggu
    Schedule::command('log:cleanup')->weekly();
    
    // Sync produk setiap 30 menit
    Schedule::command('products:sync')->everyThirtyMinutes();
    
    // Jalankan khusus hari kerja
    Schedule::command('report:daily')->weekdays()->at('08:00');

    Tambahkan satu baris ke crontab server untuk menjalankan scheduler setiap menit:

    * * * * * cd /var/www/html && php artisan schedule:run >> /dev/null 2>&1

    Testing Custom Command

    Laravel menyediakan helper untuk test command tanpa harus jalankan manual:

    public function test_report_command_runs_successfully(): void
    {
        $this->artisan('report:daily')
             ->expectsOutput('Laporan berhasil dikirim')
             ->assertExitCode(0);
    }
    
    // Test dengan argumen
    public function test_report_with_date(): void
    {
        $this->artisan('report:send', [
            'type'   => 'sales',
            '--date' => '2025-04-01',
        ])->assertExitCode(0);
    }

    Baca Juga

    Kalau Anda butuh tim untuk membangun dan maintain aplikasi Laravel Anda, lihat layanan pengembangan aplikasi kami.

  • Concurrency Adalah? Cara Kerja Concurrency di Laravel 12

    Concurrency adalah kemampuan menjalankan beberapa proses secara bersamaan (paralel), bukan satu per satu secara berurutan. Di dunia web modern, concurrency artinya bisa memanggil tiga API eksternal sekaligus dan menunggu semuanya selesai — dibanding menunggu satu selesai, baru mulai berikutnya. Laravel 12 memperkenalkan Concurrency facade yang membuat pola ini jauh lebih mudah diimplementasikan di aplikasi PHP.

    Artikel ini menjelaskan apa itu Concurrency di Laravel 12, bagaimana cara kerjanya secara teknis, dan kapan sebaiknya dipakai — beserta kasus di mana lebih baik tidak menggunakannya.

    Apa Itu Concurrency di Laravel 12?

    Concurrency adalah teknik eksekusi paralel di mana beberapa operasi berjalan secara bersamaan, bukan berurutan. Dalam konteks Laravel, concurrency artinya Anda bisa menjalankan beberapa closure PHP secara paralel dan mengumpulkan semua hasilnya sekaligus.

    Concurrency facade di Laravel 12 memungkinkan Anda menjalankan beberapa closure secara bersamaan (paralel) dan menunggu semua hasilnya. Ini berguna saat Anda punya beberapa operasi yang tidak bergantung satu sama lain dan masing-masing membutuhkan waktu, seperti memanggil beberapa API eksternal atau query ke database berbeda.

    Tanpa concurrency (sequential):

    // Total waktu: 1 + 2 + 1.5 = ~4.5 detik
    $weather  = fetchWeather($city);     // 1 detik
    $stock    = fetchStockPrice($code);  // 2 detik
    $exchange = fetchExchangeRate();     // 1.5 detik

    Dengan concurrency (paralel):

    use Illuminate\Support\Facades\Concurrency;
    
    // Total waktu: ~2 detik (terlama)
    [$weather, $stock, $exchange] = Concurrency::run([
        fn() => fetchWeather($city),
        fn() => fetchStockPrice($code),
        fn() => fetchExchangeRate(),
    ]);

    Bagaimana Cara Kerjanya?

    Laravel Concurrency bekerja dengan membuka beberapa proses PHP secara paralel (bukan thread). Setiap closure dijalankan di child process terpisah, hasilnya di-serialize dan dikembalikan ke parent process.

    Ini berbeda dengan async programming di Node.js atau Go. Laravel Concurrency tidak non-blocking event loop, melainkan multi-process. Artinya ada overhead untuk setiap proses baru, jadi tidak ideal untuk tugas yang sangat pendek (di bawah 100ms).

    Contoh Penggunaan Nyata

    Dashboard analytics yang perlu data dari beberapa sumber:

    use Illuminate\Support\Facades\Concurrency;
    
    [$orders, $revenue, $topProducts, $visitors] = Concurrency::run([
        fn() => Order::thisMonth()->count(),
        fn() => Order::thisMonth()->sum('total'),
        fn() => Product::topSelling(5)->get(),
        fn() => Analytics::uniqueVisitors(today()),
    ]);
    
    return view('dashboard', compact('orders', 'revenue', 'topProducts', 'visitors'));

    Tanpa concurrency, kalau tiap query butuh 200ms, total jadi 800ms. Dengan concurrency, total sekitar 200ms (sesuai yang terlama).

    Defer: Jalankan Setelah Response Dikirim

    Laravel 12 juga punya Concurrency::defer() — mirip dengan concurrency, tapi closure dijalankan setelah response HTTP sudah dikirim ke browser.

    use Illuminate\Support\Facades\Concurrency;
    
    // Response langsung dikirim ke user
    // Tiga closure di bawah jalan di background
    Concurrency::defer([
        fn() => $this->updateLastLogin($user),
        fn() => $this->logActivity($user, 'login'),
        fn() => $this->syncWithCRM($user),
    ]);
    
    return redirect()->intended('dashboard');

    Berguna untuk aksi “fire and forget” yang tidak perlu hasilnya sebelum response dikirim.

    Kapan Pakai, Kapan Tidak?

    Cocok untuk:

    • Beberapa panggilan API eksternal yang independent
    • Query ke database berbeda (multi-connection) yang tidak saling bergantung
    • Proses komputasi berat yang bisa diparalelkan

    Tidak cocok untuk:

    • Tugas sangat cepat (overhead proses lebih mahal daripada keuntungannya)
    • Operasi yang saling bergantung (output A dibutuhkan input B)
    • Operasi yang butuh akses ke state yang sama (tidak ada shared memory antar proses)

    Concurrency vs Queue vs Async: Apa Bedanya?

    Banyak developer bingung membedakan tiga konsep ini. Berikut perbedaannya dalam konteks Laravel:

    • Concurrency (Laravel 12) — Proses berjalan paralel, hasilnya ditunggu langsung di request yang sama. Ideal untuk operasi I/O yang independent dalam satu request.
    • Queue (Laravel Queue) — Tugas dikirim ke antrian dan dikerjakan di background oleh worker terpisah. Tidak menunggu hasilnya. Ideal untuk email, notifikasi, proses besar yang tidak perlu hasilnya segera.
    • Async (JavaScript/Node.js) — Non-blocking event loop. PHP secara native bukan bahasa async, jadi Laravel Concurrency mensimulasikannya via multi-process.

    Aturan sederhana: Butuh hasilnya sekarang di dalam request? → Gunakan Concurrency. Tidak butuh hasilnya segera? → Gunakan Queue.

    Pitfalls dan Hal yang Perlu Diperhatikan

    Tidak Ada Shared State Antar Proses

    Karena setiap closure berjalan di child process terpisah, tidak ada shared memory. Variabel, singleton, atau cache in-memory yang diubah di satu closure tidak akan terlihat di closure lain atau di parent process.

    Exception Handling

    Jika salah satu closure throw exception, Concurrency::run() akan menangkapnya dan throw ulang di parent process. Pastikan setiap closure ditangani dengan baik:

    [$result1, $result2] = Concurrency::run([
        fn() => safeApiCall1(),
        fn() => safeApiCall2(),
    ]);

    Database Connection per Process

    Setiap child process butuh koneksi database sendiri. Pastikan database connection pool Anda cukup untuk menampung jumlah proses konkuren yang Anda jalankan.

    Baca Juga

    FAQ: Pertanyaan Umum tentang Concurrency di Laravel

    Apa itu concurrency dalam pemrograman?

    Concurrency adalah kemampuan sistem menjalankan beberapa proses atau operasi secara bersamaan. Concurrency artinya tidak ada satu proses yang harus menunggu proses lain selesai sebelum bisa mulai — semua bisa berjalan paralel.

    Apa perbedaan concurrency dan parallelism?

    Concurrency adalah konsep logis (beberapa pekerjaan dalam proses yang tumpang-tindih), sementara parallelism adalah eksekusi fisik secara bersamaan di beberapa CPU core. Laravel Concurrency di balik layar menggunakan multi-process, yang merupakan bentuk true parallelism.

    Apakah Laravel Concurrency tersedia di Laravel 11?

    Concurrency facade diperkenalkan di Laravel 11 (sebagai fitur eksperimental) dan disempurnakan di Laravel 12. Jika Anda menggunakan Laravel 11.x, pastikan versi Laravel Anda sudah mendukung Illuminate\Support\Facades\Concurrency.

    Apakah laravel concurrency aman untuk production?

    Ya, aman untuk production selama Anda memahami limitasinya: tidak ada shared state antar proses, exception harus ditangani dengan baik, dan jumlah concurrent process harus sesuai dengan kapasitas server (RAM dan database connections).

    Concurrency artinya apa dalam bahasa Indonesia?

    Concurrency artinya “kebersamaan” atau “pemrosesan bersamaan” — kemampuan menjalankan beberapa tugas secara paralel. Dalam konteks Laravel, concurrency artinya beberapa closure PHP dieksekusi secara bersamaan di proses terpisah.

    Tertarik Membangun Aplikasi Laravel yang Performant?

    Memahami fitur seperti Concurrency adalah bagian dari membangun aplikasi Laravel yang benar-benar scalable. Jika tim Anda butuh bantuan merancang arsitektur aplikasi PHP yang efisien — mulai dari pemilihan teknik pemrosesan yang tepat hingga deployment di server production — tim Arrazy Inovasi siap membantu.

    Ada proyek yang ingin didiskusikan? Konsultasi gratis dengan tim kami.

  • Tutorial Laravel 12: Menggunakan Context Facade untuk Propagasi Data

    Tutorial Laravel 12: Menggunakan Context Facade untuk Propagasi Data

    Laravel 12 nambah fitur baru namanya Context. Kalau kamu pernah bingung gimana caranya nyebarin data kayak tenant_id, request_id, atau user_id ke semua log, job, dan event tanpa harus ngoper variabel ke mana-mana — ini solusinya.

    Tutorial ini bahas Context dari dasar sampai implementasi nyata. Cocok buat kamu yang udah familiar sama Laravel tapi belum pernah pakai Context facade.

    Apa Itu Context di Laravel 12?

    Context adalah cara Laravel nyimpen data yang terikat sama satu request atau satu eksekusi. Data ini bisa diakses dari mana aja tanpa harus ngoper variabel ke tiap fungsi atau class.

    Bayangin kamu punya aplikasi multi-tenant. Setiap request butuh tahu tenant_id-nya siapa. Biasanya kamu harus:

    • Ngirim $tenantId ke controller
    • Terus ke service
    • Terus ke repository
    • Terus ke job
    • Terus ke log

    Ribet. Context bikin ini jadi simpel:

    use Illuminate\Support\Facades\Context;
    
    // Set sekali di middleware
    Context::add('tenant_id', 123);
    
    // Ambil di mana aja
    $tenantId = Context::get('tenant_id'); // 123

    Data ini otomatis ikut ke log, job, event, dan exception yang terjadi dalam request yang sama.

    Cara Pakai Context: Dasar

    Context tersedia lewat facade Illuminate\Support\Facades\Context atau helper context().

    Menambah Data ke Context

    Context::add('request_id', 'REQ-20260525-0001');
    Context::add('user_id', 42);
    
    // Atau sekaligus
    Context::add([
        'request_id' => 'REQ-20260525-0001',
        'user_id' => 42,
    ]);

    Mengambil Data dari Context

    $requestId = Context::get('request_id');
    
    // Dengan default value kalau tidak ada
    $userId = Context::get('user_id', 0);

    Menghapus Data dari Context

    // Hapus satu key
    Context::forget('request_id');
    
    // Hapus semua
    Context::flush();

    Studi Kasus 1: Request ID di Semua Log

    Masalah klasik: saat ada error, susah tahu log mana yang terkait satu request. Apalagi kalau traffic tinggi, log campur aduk.

    Solusinya: bikin middleware yang nambah request ID ke Context.

    <?php
    
    namespace App\Http\Middleware;
    
    use Closure;
    use Illuminate\Http\Request;
    use Illuminate\Support\Facades\Context;
    use Illuminate\Support\Str;
    
    class AddRequestContext
    {
        public function handle(Request $request, Closure $next): mixed
        {
            Context::add([
                'request_id' => Str::uuid()->toString(),
                'url'        => $request->fullUrl(),
                'method'     => $request->method(),
                'ip'         => $request->ip(),
                'user_id'    => $request->user()?->id,
            ]);
    
            return $next($request);
        }
    }

    Daftarkan di bootstrap/app.php:

    ->withMiddleware(function (Middleware $middleware) {
        $middleware->prepend(AddRequestContext::class);
    })

    Sekarang semua log otomatis punya context:

    Log::info('Memproses pembayaran');
    
    // Output di log:
    // [2026-05-25 10:23:45] local.INFO: Memproses pembayaran 
    // {"request_id":"abc-123","url":"/checkout","user_id":42}

    Kalau ada error, tinggal cari semua log dengan request_id yang sama. Debugging jadi jauh lebih gampang.

    Studi Kasus 2: Multi-Tenancy dengan Context

    Aplikasi multi-tenant butuh tenant_id di hampir semua query. Biasanya kamu harus ngirim $tenantId ke mana-mana. Dengan Context, cukup set sekali di middleware:

    <?php
    
    namespace App\Http\Middleware;
    
    use Closure;
    use Illuminate\Http\Request;
    use Illuminate\Support\Facades\Context;
    
    class ResolveTenant
    {
        public function handle(Request $request, Closure $next): mixed
        {
            // Resolve tenant dari subdomain atau header
            $tenant = $this->getTenantFromRequest($request);
    
            Context::add('tenant_id', $tenant->id);
    
            return $next($request);
        }
    
        private function getTenantFromRequest(Request $request)
        {
            // Contoh: dari subdomain
            $subdomain = explode('.', $request->getHost())[0];
            return Tenant::where('subdomain', $subdomain)->firstOrFail();
        }
    }

    Sekarang di service atau repository, tinggal ambil dari Context:

    class OrderService
    {
        public function getCurrentTenantOrders()
        {
            $tenantId = Context::get('tenant_id');
    
            return Order::where('tenant_id', $tenantId)->get();
        }
    }

    Catatan penting: Jangan bergantung 100% pada Context untuk data bisnis kritis. Kalau kamu jalanin Artisan command atau test, Context mungkin kosong. Selalu kasih default value atau cek null.

    Studi Kasus 3: Propagasi Context ke Queue Jobs

    Masalah: ketika request trigger job di queue, context (request ID, user ID) hilang karena job jalan di worker terpisah.

    Kabar baiknya: Context otomatis dipropagasi ke jobs kalau job implement ShouldQueue.

    <?php
    
    namespace App\Jobs;
    
    use Illuminate\Bus\Queueable;
    use Illuminate\Contracts\Queue\ShouldQueue;
    use Illuminate\Foundation\Bus\Dispatchable;
    use Illuminate\Queue\InteractsWithQueue;
    use Illuminate\Support\Facades\Context;
    use Illuminate\Support\Facades\Log;
    
    class ProcessPayment implements ShouldQueue
    {
        use Dispatchable, InteractsWithQueue, Queueable;
    
        public function __construct(
            private int $orderId
        ) {}
    
        public function handle(): void
        {
            // Context dari request yang dispatch job ini otomatis tersedia
            $requestId = Context::get('request_id');
    
            Log::info("Memproses pembayaran order {$this->orderId}", [
                'request_id' => $requestId,
            ]);
    
            // proses pembayaran...
        }
    }

    Best practice: Untuk data penting kayak tenant_id, simpan juga sebagai property Job. Jangan cuma andalin Context, karena lifecycle worker bisa beda-beda.

    Studi Kasus 4: Hidden Context untuk Data Sensitif

    Kadang kamu butuh data di Context tapi nggak mau muncul di log (misalnya token atau API key).

    // Tambah context tersembunyi — tidak masuk ke log
    Context::addHidden([
        'payment_token' => $request->payment_token,
        'api_key'       => config('services.payment.key'),
    ]);
    
    // Ambil di bagian lain
    $token = Context::getHidden('payment_token');

    Data ini tetap bisa diakses di kode, tapi nggak akan muncul di log output.

    Kapan Pakai Context vs Dependency Injection?

    Context bukan pengganti dependency injection. Ini panduan kapan pakai mana:

    Pakai Context kalau:

    • Data perlu tersebar ke banyak layer (log, job, event) tanpa ubah signature
    • Multi-tenant: tenant_id butuh ada di mana-mana
    • Request tracing: request_id untuk debugging
    • Feature flags: tracking fitur apa yang aktif per request

    Pakai Dependency Injection kalau:

    • Data bisnis yang jelas dependensinya (misal OrderService butuh PaymentGateway)
    • Konfigurasi statis (cukup lewat config atau env)
    • Kode yang perlu di-test dengan mock/stub

    Intinya: Context untuk data “ambient” yang perlu ada di mana-mana. DI untuk dependensi eksplisit yang jelas.

    Testing Kode yang Pakai Context

    Di test, kamu harus set Context secara manual:

    use Illuminate\Support\Facades\Context;
    
    public function test_service_menggunakan_tenant_dari_context()
    {
        Context::flush(); // Pastikan kosong dulu
        Context::add('tenant_id', 10);
    
        $service = app(OrderService::class);
        $orders = $service->getCurrentTenantOrders();
    
        $this->assertTrue(
            $orders->every(fn ($order) => $order->tenant_id === 10)
        );
    }

    Jangan lupa Context::flush() di setUp() atau tearDown() biar nggak ada kebocoran state antar test.

    Pitfall yang Harus Dihindari

    1. Overuse Context = Global State

    Kalau semua data masuk Context, kode jadi susah di-trace. Pakai Context cuma untuk data yang emang perlu ada di mana-mana.

    2. Lupa Guard di CLI/Artisan

    Artisan command jalan tanpa request, jadi Context bisa kosong. Selalu kasih default:

    $tenantId = Context::get('tenant_id');
    
    if (is_null($tenantId)) {
        throw new \RuntimeException('Tenant ID tidak tersedia di context');
    }

    3. Ubah Context di Layer Bawah

    Kalau middleware A set tenant_id, jangan ubah lagi di service atau repository. Bikin aturan: Context cuma di-set di middleware, layer lain cuma baca.

    Ringkasan

    Context facade di Laravel 12 bikin kamu bisa nyebarin data ke seluruh aplikasi tanpa harus ngoper variabel ke mana-mana. Cocok buat:

    • Request tracing dengan request_id
    • Multi-tenancy dengan tenant_id
    • Feature flags dan debugging
    • Propagasi data ke log, job, dan event

    Tapi ingat: jangan overuse. Pakai Context untuk data ambient, pakai DI untuk dependensi eksplisit.

    Baca Juga

    Butuh tim yang bantu setup observability dan logging yang proper di aplikasi Laravel? Lihat layanan pengembangan aplikasi kami.

  • Apa Itu Contract di Laravel 12? Penjelasan Simpel + Contoh Kode

    Bayangkan Anda membangun fitur notifikasi. Hari ini kirim via email, bulan depan ditambah WhatsApp, tahun depan mungkin push notification. Kalau kode Anda langsung bergantung ke implementasi email spesifik, setiap perubahan akan memaksa Anda menyentuh banyak file sekaligus.

    Di sinilah Contract di Laravel 12 berguna.

    Apa Itu Contract di Laravel 12?

    Contract di Laravel adalah sekumpulan interface yang mendefinisikan “kontrak perilaku” sebuah layanan. Mereka berada di namespace Illuminate\Contracts dan tidak berisi implementasi — hanya daftar method yang harus dipenuhi oleh siapapun yang mengimplementasikannya.

    Singkatnya: Contract mendefinisikan apa yang bisa dilakukan, bukan bagaimana melakukannya.

    Perbedaan Contract dan Interface Biasa

    Secara teknis, Contract Laravel adalah interface PHP biasa. Yang membedakannya adalah tujuan dan skala: Contract Laravel menstandardisasi layanan inti framework (cache, queue, auth, storage, dll.) sehingga Anda bisa menukar implementasinya tanpa mengubah kode yang memakainya.

    Contoh: Illuminate\Contracts\Cache\Store mendefinisikan method get, put, forget, dll. Baik driver Redis maupun Memcached sama-sama mengimplementasikan contract ini — kode Anda tidak perlu tahu mana yang aktif.

    Membuat Contract Sendiri

    Selain contract bawaan Laravel, Anda bisa membuat contract untuk layanan buatan sendiri. Contoh sederhana untuk layanan notifikasi:

    // app/Contracts/NotificationServiceContract.php
    namespace App\Contracts;
    
    interface NotificationServiceContract
    {
        public function send(string $recipient, string $message): bool;
    }
    

    Lalu buat implementasinya:

    // app/Services/EmailNotificationService.php
    namespace App\Services;
    
    use App\Contracts\NotificationServiceContract;
    
    class EmailNotificationService implements NotificationServiceContract
    {
        public function send(string $recipient, string $message): bool
        {
            // logika kirim email
            return true;
        }
    }
    

    Binding Contract ke Service Container

    Daftarkan binding di AppServiceProvider atau service provider khusus:

    use App\Contracts\NotificationServiceContract;
    use App\Services\EmailNotificationService;
    
    public function register(): void
    {
        $this->app->bind(
            NotificationServiceContract::class,
            EmailNotificationService::class
        );
    }
    

    Setelah itu, gunakan contract via dependency injection di controller atau class lain:

    use App\Contracts\NotificationServiceContract;
    
    class OrderController extends Controller
    {
        public function __construct(
            private NotificationServiceContract $notifier
        ) {}
    
        public function store(Request $request)
        {
            // ... proses order
            $this->notifier->send($request->email, 'Pesanan diterima!');
        }
    }
    

    Besok ketika Anda ingin ganti ke WhatsApp, cukup buat WhatsAppNotificationService, ubah satu baris binding di service provider — tidak ada yang berubah di controller.

    Kapan Sebaiknya Menggunakan Contract?

    Contract paling berguna ketika:

    • Implementasi layanan bisa berubah di masa depan (storage, payment gateway, notifikasi)
    • Anda ingin membuat unit test yang tidak bergantung ke implementasi nyata (mock mudah dibuat dari interface)
    • Tim besar — contract menjadi “dokumen hidup” yang mendefinisikan API internal antar modul

    Untuk fungsi sederhana yang tidak akan berubah, Contract justru menambah kompleksitas yang tidak perlu. Gunakan dengan pertimbangan, bukan sebagai aturan baku.

    Contract vs Facade di Laravel

    Laravel punya Facade yang memberikan akses statis ke layanan container. Contract dan Facade sering digunakan untuk tujuan serupa, tapi berbeda pendekatan. Facade lebih ringkas untuk kode cepat; Contract lebih eksplisit dan mudah di-mock saat testing. Untuk aplikasi skala besar dengan banyak unit test, Contract umumnya lebih direkomendasikan.

    Kalau Anda sedang membangun aplikasi Laravel dan butuh konsultasi arsitektur atau tim pengembang, kami di Arrazy Inovasi siap membantu.

    Lihat layanan pengembangan aplikasi kami →

  • Tutorial Laravel 12 Job Batching: Implementasi, Progress, dan Error Handling

    Bayangkan Anda perlu kirim email ke 5.000 pengguna sekaligus, atau proses 1.000 gambar setelah upload. Kalau dijalankan satu per satu lewat queue biasa, Anda tidak tahu kapan semuanya selesai, dan tidak bisa jalankan aksi “setelah semua beres”.

    Job Batching di Laravel menyelesaikan masalah ini. Artikel ini membahas cara kerjanya, implementasi lengkap dengan contoh kode, dan cara handle error dalam batch.

    Apa Itu Job Batching?

    Job Batching memungkinkan Anda mengelompokkan beberapa job ke dalam satu batch, lalu mendefinisikan callback yang dijalankan:

    • Saat semua job berhasil (then)
    • Saat ada job yang gagal (catch)
    • Saat semua job selesai (berhasil atau gagal) (finally)

    Setup: Membuat Tabel Batch

    php artisan make:batches-table
    php artisan migrate

    Ini membuat tabel job_batches yang menyimpan status setiap batch.

    Membuat Job yang Batchable

    Job harus implement ShouldQueue dan gunakan trait Batchable:

    <?php
    
    namespace AppJobs;
    
    use AppModelsUser;
    use AppMailPromotionMail;
    use IlluminateBusBatchable;
    use IlluminateBusQueueable;
    use IlluminateContractsQueueShouldQueue;
    use IlluminateFoundationBusDispatchable;
    use IlluminateQueueInteractsWithQueue;
    use IlluminateSupportFacadesMail;
    
    class SendPromotionEmail implements ShouldQueue
    {
        use Batchable, Dispatchable, InteractsWithQueue, Queueable;
    
        public function __construct(
            private User $user
        ) {}
    
        public function handle(): void
        {
            // Cek apakah batch sudah di-cancel
            if ($this->batch()->cancelled()) {
                return;
            }
    
            Mail::to($this->user)->send(new PromotionMail());
        }
    }

    Mengirim Batch

    use AppJobsSendPromotionEmail;
    use IlluminateSupportFacadesBus;
    
    $users = User::where('subscribed', true)->get();
    
    $batch = Bus::batch(
        $users->map(fn ($user) => new SendPromotionEmail($user))->toArray()
    )->then(function (Batch $batch) {
        // Dijalankan saat semua job berhasil
        Log::info("Batch selesai: {$batch->totalJobs} email terkirim.");
    })->catch(function (Batch $batch, Throwable $e) {
        // Dijalankan saat ada job yang gagal
        Log::error("Batch error: {$e->getMessage()}");
    })->finally(function (Batch $batch) {
        // Selalu dijalankan saat batch selesai (berhasil atau tidak)
        Cache::forget('promotion-batch-running');
    })->name('Kirim Email Promosi')
      ->allowFailures()  // batch tetap lanjut meski ada job gagal
      ->dispatch();
    
    // Simpan ID batch untuk monitor progress
    return $batch->id;

    Monitor Progress Batch

    Ambil info batch berdasarkan ID:

    use IlluminateSupportFacadesBus;
    
    $batch = Bus::findBatch($batchId);
    
    // Info yang tersedia
    $batch->id;
    $batch->name;
    $batch->totalJobs;
    $batch->pendingJobs;
    $batch->failedJobs;
    $batch->processedJobs();  // totalJobs - pendingJobs
    $batch->progress();       // 0-100 persen
    $batch->finished();       // apakah sudah selesai
    $batch->cancelled();      // apakah di-cancel
    

    Contoh endpoint API untuk polling progress:

    Route::get('/batches/{batchId}/progress', function (string $batchId) {
        $batch = Bus::findBatch($batchId);
    
        if (!$batch) {
            return response()->json(['error' => 'Batch tidak ditemukan'], 404);
        }
    
        return response()->json([
            'progress'     => $batch->progress(),
            'total'        => $batch->totalJobs,
            'processed'    => $batch->processedJobs(),
            'failed'       => $batch->failedJobs,
            'finished'     => $batch->finished(),
        ]);
    })->middleware('auth');

    Cancel Batch

    $batch = Bus::findBatch($batchId);
    $batch->cancel();

    Job yang belum diproses akan skip sendiri karena pengecekan $this->batch()->cancelled() di awal method handle().

    Batch dengan Job Berantai

    Anda bisa chain batch: jalankan batch kedua setelah batch pertama selesai:

    Bus::batch([
        new ProcessImages($product),
        new GenerateThumbnails($product),
    ])->then(function (Batch $batch) use ($product) {
        // Setelah gambar dan thumbnail selesai, generate sitemap
        GenerateSitemap::dispatch();
    })->dispatch();

    Praktis: Batch untuk Impor CSV

    Skenario umum: impor data dari file CSV besar.

    <?php
    
    namespace AppJobs;
    
    use IlluminateBusBatchable;
    use IlluminateBusQueueable;
    use IlluminateContractsQueueShouldQueue;
    
    class ImportCsvRow implements ShouldQueue
    {
        use Batchable, Queueable;
    
        public function __construct(private array $row) {}
    
        public function handle(): void
        {
            if ($this->batch()->cancelled()) return;
    
            Product::updateOrCreate(
                ['sku'  => $this->row['sku']],
                ['name' => $this->row['name'], 'price' => $this->row['price']]
            );
        }
    }
    
    // Di controller
    $rows  = CsvParser::parse($file);
    $jobs  = collect($rows)->map(fn ($row) => new ImportCsvRow($row));
    
    $batch = Bus::batch($jobs->toArray())
                ->name('Import Produk')
                ->allowFailures()
                ->dispatch();
    
    return redirect()->route('imports.progress', $batch->id);

    Baca Juga

    Butuh tim untuk implementasi background processing di aplikasi Laravel Anda? Lihat layanan pengembangan aplikasi kami.

  • Notification di Laravel 12: Email, Database, dan Channel Kustom

    Hampir semua aplikasi web butuh notifikasi: konfirmasi order, reset password, atau pemberitahuan saat ada komentar baru. Laravel punya sistem notifikasi yang cukup fleksibel: satu kelas bisa kirim ke email, database, Slack, dan channel lain sekaligus.

    Artikel ini membahas cara kerja notification di Laravel 12, mulai dari membuat kelas notifikasi, kirim via email dan database, sampai membuat channel kustom.

    Membuat Kelas Notifikasi

    php artisan make:notification OrderConfirmed

    File dibuat di app/Notifications/OrderConfirmed.php:

    <?php
    
    namespace AppNotifications;
    
    use AppModelsOrder;
    use IlluminateBusQueueable;
    use IlluminateNotificationsNotification;
    use IlluminateNotificationsMessagesMailMessage;
    use IlluminateContractsQueueShouldQueue;
    
    class OrderConfirmed extends Notification implements ShouldQueue
    {
        use Queueable;
    
        public function __construct(
            private Order $order
        ) {}
    
        public function via(object $notifiable): array
        {
            return ['mail', 'database'];
        }
    
        public function toMail(object $notifiable): MailMessage
        {
            return (new MailMessage)
                ->subject("Order #{$this->order->id} Dikonfirmasi")
                ->greeting("Halo, {$notifiable->name}!")
                ->line("Order Anda telah kami terima dan sedang diproses.")
                ->action('Lihat Detail Order', route('orders.show', $this->order))
                ->line("Terima kasih sudah berbelanja.");
        }
    
        public function toDatabase(object $notifiable): array
        {
            return [
                'order_id' => $this->order->id,
                'message'  => "Order #{$this->order->id} dikonfirmasi",
                'url'      => route('orders.show', $this->order),
            ];
        }
    }

    Notifiable Trait

    Model yang ingin menerima notifikasi harus menggunakan trait Notifiable. Model User bawaan Laravel sudah menyertakan ini:

    use IlluminateNotificationsNotifiable;
    
    class User extends Authenticatable
    {
        use Notifiable;
    }

    Untuk model lain — misalnya Admin atau Customer — tambahkan trait yang sama.

    Mengirim Notifikasi

    // Lewat instance model
    $user->notify(new OrderConfirmed($order));
    
    // Lewat Notification facade (tanpa model spesifik)
    Notification::send($users, new OrderConfirmed($order));
    
    // On-demand — kirim ke email tanpa model User
    Notification::route('mail', 'admin@example.com')
                ->notify(new OrderConfirmed($order));

    Karena kelas ini implement ShouldQueue, notifikasi akan diproses di background queue, tidak memperlambat response HTTP.

    Notifikasi Email: Kustomisasi Template

    Untuk kontrol penuh atas tampilan email, publish template bawaan Laravel:

    php artisan vendor:publish --tag=laravel-mail

    Template disimpan di resources/views/vendor/mail/. Edit sesuai kebutuhan brand Anda.

    Kalau mau pakai Markdown template yang lebih kaya:

    php artisan make:notification OrderShipped --markdown=mail.order.shipped

    Template dibuat di resources/views/mail/order/shipped.blade.php:

    @component('mail::message')
    # Order Anda Dalam Perjalanan
    
    Pesanan **#{{ $order->id }}** sedang dikirim ke alamat Anda.
    
    @component('mail::button', ['url' => $trackingUrl])
    Lacak Pengiriman
    @endcomponent
    
    Estimasi tiba: **{{ $order->estimated_arrival }}**
    
    Salam,
    {{ config('app.name') }}
    @endcomponent

    Notifikasi Database

    Untuk simpan notifikasi di database (biasanya untuk fitur notifikasi in-app), buat tabel dulu:

    php artisan make:notifications-table
    php artisan migrate

    Ambil notifikasi yang belum dibaca:

    // Semua notifikasi
    $notifications = auth()->user()->notifications;
    
    // Hanya yang belum dibaca
    $unread = auth()->user()->unreadNotifications;
    
    // Tandai sudah dibaca
    auth()->user()->unreadNotifications->markAsRead();
    
    // Tandai satu notifikasi sudah dibaca
    $notification->markAsRead();

    Channel Kustom

    Kalau perlu kirim via WhatsApp, Telegram, atau sistem internal, buat channel kustom:

    <?php
    
    namespace AppNotificationsChannels;
    
    use IlluminateNotificationsNotification;
    
    class WhatsAppChannel
    {
        public function send(object $notifiable, Notification $notification): void
        {
            $message = $notification->toWhatsApp($notifiable);
    
            // Kirim via WhatsApp API
            app(WhatsAppService::class)->send(
                $notifiable->phone,
                $message
            );
        }
    }

    Daftarkan di method via():

    public function via(object $notifiable): array
    {
        return [WhatsAppChannel::class, 'database'];
    }
    
    public function toWhatsApp(object $notifiable): string
    {
        return "Order #{$this->order->id} Anda sudah dikonfirmasi.";
    }

    Baca Juga

    Butuh tim yang bantu implementasi sistem notifikasi di aplikasi Laravel Anda? Lihat layanan pengembangan aplikasi kami.