Author: vandyahmad24

  • Contoh Penggunaan Context di Laravel 12: Request Tracing dan Queue Propagation

    Artikel sebelumnya menjelaskan apa itu Context facade di Laravel 12. Artikel ini fokus pada implementasi nyata: bagaimana Context dipakai untuk trace request ID, propagasi ke jobs, dan debugging yang lebih mudah.

    Studi Kasus 1: Request ID di Semua Log

    Masalah klasik: saat ada error, sulit tahu log mana yang terkait satu request. Solusi dengan 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 di seluruh request otomatis punya context:

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

    Studi Kasus 2: Propagasi Context ke Queue Jobs

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

    Solusi: Context secara otomatis dipropagasi ke jobs jika menggunakan Illuminate\Queue\SerializesModels atau kalau job implement ShouldQueue — tapi kita harus pastikan data context yang ingin dipropagasi ada di “hydrated context”.

    <?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...
        }
    }

    Studi Kasus 3: Hidden Context untuk Data Sensitif

    Beberapa context tidak ingin muncul di log tapi perlu tersedia di kode:

    // 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');
    

    Studi Kasus 4: Debugging Feature Flag

    <?php
    
    namespace App\Http\Middleware;
    
    use Closure;
    use Illuminate\Http\Request;
    use Illuminate\Support\Facades\Context;
    
    class TrackFeatureFlags
    {
        public function handle(Request $request, Closure $next): mixed
        {
            $user = $request->user();
    
            if ($user) {
                Context::add([
                    'features' => [
                        'new_checkout'     => $user->hasFeature('new-checkout'),
                        'ai_recommendations' => $user->hasFeature('ai-rec'),
                    ],
                ]);
            }
    
            return $next($request);
        }
    }
    

    Kalau ada bug laporan dari user tertentu, cek log dan langsung tahu fitur apa yang aktif saat itu.

    Dehydrate dan Hydrate untuk Custom Serialization

    Untuk objek yang tidak bisa di-serialize otomatis:

    Context::dehydrating(function (Context $context) {
        // Ubah Carbon ke string saat queue job dikirim
        if ($context->has('started_at')) {
            $context->add('started_at', $context->get('started_at')->toIso8601String());
        }
    });
    
    Context::hydrated(function (Context $context) {
        // Kembalikan ke Carbon saat job diproses
        if ($context->has('started_at')) {
            $context->add('started_at', Carbon::parse($context->get('started_at')));
        }
    });

    Baca Juga

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

  • 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.

  • 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.

  • Apa Itu Concurrency di Laravel 12 dan Kapan Menggunakannya

    Di dunia web modern, ada tugas yang lebih cepat diselesaikan secara paralel daripada satu per satu. Panggil tiga API sekaligus alih-alih menunggu satu per satu. Laravel 12 punya fitur Concurrency yang membuat ini mudah dilakukan.

    Artikel ini menjelaskan apa itu Concurrency di Laravel 12, cara kerjanya, dan kapan sebaiknya dipakai.

    Apa Itu Concurrency di Laravel 12?

    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 IlluminateSupportFacadesConcurrency;
    
    // 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 IlluminateSupportFacadesConcurrency;
    
    [$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 IlluminateSupportFacadesConcurrency;
    
    // 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)

    Baca Juga

    Tertarik membangun aplikasi Laravel yang performa-nya dioptimalkan? Lihat layanan pengembangan aplikasi kami.

  • Apa Itu Context di Laravel 12? Propagasi Data ke Log dan Queued Jobs

    Pernah debugging log produksi dan bingung karena entri log tidak punya info konteks — tidak tahu request mana, user mana, atau proses apa yang menghasilkannya? Laravel 12 punya solusi bawaan untuk ini: fitur Context.

    Context di Laravel 12 bukan sekadar contextual binding di service container. Ini adalah fitur tersendiri yang memungkinkan Anda menyimpan data kontekstual yang otomatis disertakan di semua log dan dipropagasi ke queued jobs.

    Apa Itu Context di Laravel 12?

    Fitur Context (diperkenalkan di Laravel 11, tersedia di Laravel 12) adalah mekanisme penyimpanan data per-request yang:

    • Otomatis disertakan di setiap entri log selama request berlangsung
    • Dipropagasi ke queued jobs yang di-dispatch dalam request yang sama
    • Bersifat isolasi per-request — tidak bocor ke request lain

    Bayangkan Anda mau melacak semua aktivitas dari satu user dalam satu request. Dengan Context, cukup simpan sekali di awal, dan semua log selanjutnya otomatis menyertakan data itu.

    Cara Menggunakan Context

    Import facade-nya:

    use Illuminate\Support\Facades\Context;
    

    Simpan data ke context:

    // Di middleware atau awal request
    Context::add('user_id', auth()->id());
    Context::add('request_id', (string) Str::uuid());
    Context::add('ip', request()->ip());
    

    Setelah ini, semua log yang dibuat selama request akan otomatis menyertakan data tersebut:

    Log::info('Pengguna membuka halaman checkout');
    // Output log:
    // [2025-04-18 10:00:00] local.INFO: Pengguna membuka halaman checkout
    // {"user_id":42,"request_id":"abc-123","ip":"192.168.1.1"}
    

    Tidak perlu manual menambahkan data ke setiap pemanggilan Log::info().

    Propagasi ke Queued Jobs

    Ini bagian yang paling berguna. Saat Anda men-dispatch job dalam sebuah request, data context ikut terbawa:

    // Di controller
    Context::add('order_id', $order->id);
    ProcessPayment::dispatch($order); // context ikut ke job ini
    
    // Di dalam ProcessPayment job
    public function handle()
    {
        // Context::get('order_id') tersedia di sini
        Log::info('Memproses pembayaran');
        // log otomatis menyertakan order_id dari context
    }
    

    Tanpa fitur ini, Anda harus manually passing data context ke setiap job sebagai parameter.

    Hidden Context: Data yang Tidak Masuk ke Log

    Context punya dua lapisan: context biasa (masuk ke log) dan “hidden context” (tidak masuk ke log, tapi tetap dipropagasi ke jobs). Berguna untuk data sensitif seperti token:

    Context::addHidden('auth_token', $token); // tidak muncul di log
    Context::getHidden('auth_token');          // tapi bisa diambil di job
    

    Membaca dan Memanipulasi Context

    // Ambil satu nilai
    $userId = Context::get('user_id');
    
    // Ambil semua context
    $all = Context::all();
    
    // Cek keberadaan key
    if (Context::has('order_id')) { ... }
    
    // Hapus key tertentu
    Context::forget('request_id');
    
    // Hapus semua
    Context::flush();
    

    Praktis: Middleware untuk Context Otomatis

    Buat middleware yang mengisi context di setiap request:

    namespace App\Http\Middleware;
    
    use Closure;
    use Illuminate\Support\Facades\Context;
    use Illuminate\Support\Str;
    
    class AddRequestContext
    {
        public function handle($request, Closure $next)
        {
            Context::add('request_id', (string) Str::uuid());
            Context::add('user_id', auth()->id() ?? 'guest');
            Context::add('url', $request->url());
    
            return $next($request);
        }
    }
    

    Daftarkan di bootstrap/app.php dan semua log di aplikasi Anda otomatis punya konteks yang kaya tanpa perubahan di kode lain.

    Kalau Anda sedang membangun aplikasi Laravel dan butuh tim pengembang yang familiar dengan fitur-fitur modern Laravel 12, kami di Arrazy Inovasi siap membantu dari konsultasi hingga pengembangan penuh.

    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.