Pada materi sebelumnya, kita sudah berhasil menyiapkan guard dan memodifikasi model User agar dapat bekerja dengan JWT. Sekarang, kita perlu membahas sesuatu yang tidak kalah penting, yaitu middleware.

Nah, apa itu middleware?

Middleware bisa kita anggap sebagai gerbang pemeriksaan setiap kali ada request masuk ke aplikasi. Jadi, sebelum request benar-benar sampai ke controller, middleware akan terlebih dahulu mengecek apakah request tersebut memenuhi syarat tertentu.

Dalam konteks JWT, middleware berfungsi sebagai "satpam" yang memastikan setiap request yang masuk membawa token valid. Kalau token tidak ada, atau token tidak valid, maka request akan ditolak. Dengan begitu, hanya user yang benar-benar sudah login dan memiliki token sah yang bisa mengakses route tertentu.

Membuat Middleware Baru

Untuk membuat middleware khusus JWT, silakan jalankan perintah artisan berikut:

php artisan make:middleware JwtMiddleware

Perintah ini akan membuat sebuah file baru di:

app/Http/Middleware/JwtMiddleware.php

Mengisi Logika Middleware

Setelah file dibuat, buka JwtMiddleware.php dan isi dengan logika untuk memvalidasi token JWT. Ubah menjadi seperti berikut ini:

<?php

namespace App\Http\Middleware;

use Closure;
use Tymon\JWTAuth\Facades\JWTAuth;
use Exception;
use Illuminate\Http\Request;

class JwtMiddleware
{
    public function handle(Request $request, Closure $next)
    {
        try {
            JWTAuth::parseToken()->authenticate();
        } catch (Exception $e) {
            return response()->json(['error' => 'Unauthorized'], 401);
        }

        return $next($request);
    }
}

Namespace & Use

namespace App\Http\Middleware;

• Menandakan bahwa class ini berada di dalam folder app/Http/Middleware.
• Laravel akan tahu lokasi middleware ini saat kita registrasikan di Kernel.php.

use Closure;
use Tymon\JWTAuth\Facades\JWTAuth;
use Exception;
use Illuminate\Http\Request;

• Closure → dibutuhkan karena middleware selalu menerima parameter fungsi penutup ($next) untuk melanjutkan request.
• JWTAuth → facade dari package tymon/jwt-auth yang kita pakai untuk parsing dan validasi token.
• Exception → digunakan untuk menangkap error (misalnya token tidak ada atau tidak valid).
• Request → tipe data untuk request yang masuk.

Definisi Class

class JwtMiddleware
{
    ...
}

• Class JwtMiddleware ini adalah middleware kustom yang akan kita pakai untuk memvalidasi JWT.

Method handle

public function handle(Request $request, Closure $next)

• Method utama di setiap middleware.
• Request $request → objek yang mewakili HTTP request dari user.
• Closure $next → fungsi yang dipanggil untuk melanjutkan request ke tahap berikutnya (controller atau middleware berikutnya).

Validasi Token

try {
    JWTAuth::parseToken()->authenticate();
} catch (Exception $e) {
    return response()->json(['error' => 'Unauthorized'], 401);
}

• JWTAuth::parseToken() → mencoba membaca token yang dibawa request (biasanya di header Authorization: Bearer <token>).
• ->authenticate() → memastikan token tersebut valid dan sesuai dengan user di database.

Jika proses ini gagal (misalnya token tidak ada, sudah expired, atau tidak valid), maka blok catch akan dijalankan, dan kita mengembalikan response JSON:

{ "error": "Unauthorized" }

dengan status HTTP 401 Unauthorized.

Melanjutkan Request

return $next($request);

• Jika token valid, maka request akan diteruskan ke proses berikutnya, entah itu controller atau middleware lain.
• Inilah inti dari middleware: ia menjadi penjaga pintu. Kalau syarat lolos (token valid), pintu dibuka; kalau tidak, langsung ditolak.

Inti Logika

• Middleware ini berfungsi untuk memeriksa apakah setiap request API membawa token JWT yang valid.
• Kalau token valid → request dilanjutkan.
• Kalau token tidak valid/tidak ada → kembalikan response 401 Unauthorized.

Pendaftaran Middleware di Laravel 11/12

Pada Laravel versi lama (≤10), middleware biasanya kita daftarkan di dalam app/Http/Kernel.php. Namun, mulai Laravel 11 dan 12, struktur konfigurasi sedikit berubah:

• Semua konfigurasi utama, termasuk middleware, sekarang diletakkan di bootstrap/app.php.
• Dengan cara ini, Laravel ingin membuat proses bootstrap aplikasi lebih eksplisit dan terpusat.

Silakan buka bootstrap/app.php dan ubah menjadi seperti berikut ini:

<?php

use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;
use App\Http\Middleware\JwtMiddleware;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__ . '/../routes/web.php',
        api: __DIR__ . '/../routes/api.php',
        commands: __DIR__ . '/../routes/console.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware) {
        // Middleware untuk API
        $middleware->api(prepend: [
            \Laravel\Sanctum\Http\Middleware\EnsureFrontendRequestsAreStateful::class,
        ]);

        // Alias middleware custom
        $middleware->alias([
            'verified' => \App\Http\Middleware\EnsureEmailIsVerified::class,
            'jwt' => JwtMiddleware::class,
        ]);
    })
    ->withExceptions(function (Exceptions $exceptions) {
        //
    })->create();

Import Class

use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;
use App\Http\Middleware\JwtMiddleware;

• Application, Exceptions, dan Middleware → class bawaan Laravel yang dipakai untuk konfigurasi aplikasi.
• JwtMiddleware → middleware custom yang sudah kita buat sebelumnya.

Konfigurasi Aplikasi

return Application::configure(basePath: dirname(__DIR__))

• Membuat instance aplikasi Laravel dengan base path mengarah ke folder project utama.

Konfigurasi Routing

->withRouting(
    web: __DIR__ . '/../routes/web.php',
    api: __DIR__ . '/../routes/api.php',
    commands: __DIR__ . '/../routes/console.php',
    health: '/up',
)

• Menentukan file route yang dipakai untuk web, api, dan console.
• health: '/up' → route health check bawaan Laravel.

Konfigurasi Middleware

->withMiddleware(function (Middleware $middleware) {
    // Middleware untuk API
    $middleware->api(prepend: [
        \Laravel\Sanctum\Http\Middleware\EnsureFrontendRequestsAreStateful::class,
    ]);

    // Alias middleware custom
    $middleware->alias([
        'verified' => \App\Http\Middleware\EnsureEmailIsVerified::class,
        'jwt' => JwtMiddleware::class,
    ]);
})

• $middleware->api(prepend: [...]) Middleware yang dipasang otomatis untuk setiap request API. Di sini Laravel menambahkan EnsureFrontendRequestsAreStateful dari Sanctum.
• $middleware->alias([...]) Inilah bagian penting untuk kita: kita membuat alias agar middleware mudah dipanggil di route.
  • 'verified' → middleware bawaan Laravel untuk cek email sudah diverifikasi.
  • 'jwt' → alias untuk middleware JwtMiddleware yang tadi kita buat.

Dengan begini, kita bisa memakai middleware JWT di route dengan sangat singkat:

Route::middleware('jwt')->get('/profile', [UserController::class, 'profile']);

Konfigurasi Exception

->withExceptions(function (Exceptions $exceptions) {
    //
})

• Bagian ini digunakan untuk mengatur handler exception global.
• Misalnya kita ingin meng-custom error 404 atau menambahkan logging khusus.

Kesimpulan: Konfigurasi Middleware JWT di Laravel 11/12

1. Middleware sebagai penjaga gerbang Middleware berfungsi memeriksa setiap request yang masuk. Dalam konteks JWT, ia memastikan request membawa token yang valid. Jika valid → request dilanjutkan, jika tidak → langsung ditolak dengan status 401 Unauthorized.

2. Membuat middleware JWT Kita membuat file JwtMiddleware.php menggunakan artisan. Di dalamnya terdapat logika utama:

   • Parsing token dengan JWTAuth::parseToken()->authenticate().
   • Menangkap error jika token tidak ada, tidak valid, atau sudah kedaluwarsa.

3. Registrasi middleware di Laravel 11/12

   • Berbeda dengan versi lama (≤10), sekarang middleware tidak lagi didaftarkan di Kernel.php, tetapi di bootstrap/app.php.

   • Kita mendaftarkan alias jwt untuk JwtMiddleware. Dengan begitu, penggunaannya di route menjadi singkat dan jelas, misalnya:

     Route::middleware('jwt')->get('/profile', [UserController::class, 'profile']);
     

4. Hasil akhirnya

   • Alur API menjadi aman: hanya user yang sudah login dan memiliki token JWT sah yang bisa mengakses route tertentu.
   • Middleware JWT ini melengkapi konfigurasi guard dan model User yang sudah kita atur sebelumnya.

Dengan middleware ini, arsitektur otentikasi JWT di Laravel sudah lengkap: Guard menentukan sistem autentikasi, User model menyesuaikan data JWT, dan Middleware menjadi filter utama untuk setiap request. Pada materi berikutnya, kita akan mulai membuat controller.