Setelah kita selesai menyiapkan guard, memodifikasi model User, dan membuat middleware JWT, sekarang kita membutuhkan sebuah controller khusus yang bertugas menangani proses otentikasi.

Controller ini akan kita beri nama AuthController.

Fungsi Utama AuthController

1. Login Menerima kredensial (email & password), lalu memverifikasi data user. Jika benar, sistem akan menghasilkan token JWT yang akan dipakai user pada setiap request berikutnya.
2. Register Menangani pendaftaran user baru, menyimpan data ke database, kemudian (opsional) langsung memberikan token JWT kepada user setelah berhasil mendaftar.
3. Logout Menghapus atau meng-invalidate token JWT, sehingga user tidak bisa lagi menggunakannya untuk mengakses route yang dilindungi.
4. Profile / Me Menampilkan data user yang sedang login berdasarkan token JWT yang dibawa pada request.

Membuat Controller

Silakan jalankan perintah berikut ini:

php artisan make:controller API\AuthController

Perintah diatas akan menambahkan sebuah file baru yang terletak didalam:

App\Http\Controllers\API

Silakan buka file AuthController.php yang baru saja dibuat, kemudian masukkan kode berikut ini:

<?php

namespace App\Http\Controllers\API;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use App\Models\User;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Validator;
use Tymon\JWTAuth\Facades\JWTAuth;
use Tymon\JWTAuth\Exceptions\JWTException;

class AuthController extends Controller
{
    /**
     * Register user baru
     */
    public function register(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name'     => 'required|string|max:255',
            'email'    => 'required|email|unique:users',
            'password' => 'required|string|min:6|confirmed',
        ]);

        if ($validator->fails()) {
            return response()->json([
                'status'  => 'error',
                'message' => 'Validation failed',
                'errors'  => $validator->errors()
            ], 422);
        }

        $user = User::create([
            'name'     => $request->name,
            'email'    => $request->email,
            'password' => Hash::make($request->password),
        ]);

        $token = JWTAuth::fromUser($user);

        return response()->json([
            'status'  => 'success',
            'message' => 'User successfully registered',
            'data'    => [
                'user'  => $user,
                'token' => $this->respondWithToken($token),
            ]
        ], 201);
    }

    /**
     * Login user
     */
    public function login(Request $request)
    {
        $credentials = $request->only('email', 'password');

        try {
            if (!$token = JWTAuth::attempt($credentials)) {
                return response()->json([
                    'status'  => 'error',
                    'message' => 'Invalid credentials'
                ], 401);
            }
        } catch (JWTException $e) {
            return response()->json([
                'status'  => 'error',
                'message' => 'Could not create token',
                'error'   => $e->getMessage()
            ], 500);
        }

        return response()->json([
            'status'  => 'success',
            'message' => 'Login successful',
            'data'    => $this->respondWithToken($token),
        ]);
    }

    /**
     * Logout user (invalidate token)
     */
    public function logout()
    {
        try {
            JWTAuth::invalidate(JWTAuth::getToken());

            return response()->json([
                'status'  => 'success',
                'message' => 'User logged out successfully'
            ]);
        } catch (JWTException $e) {
            return response()->json([
                'status'  => 'error',
                'message' => 'Failed to logout, token invalid',
                'error'   => $e->getMessage()
            ], 500);
        }
    }

    /**
     * Refresh token
     */
    public function refresh()
    {
        try {
            $newToken = JWTAuth::refresh(JWTAuth::getToken());

            return response()->json([
                'status'  => 'success',
                'message' => 'Token refreshed',
                'data'    => $this->respondWithToken($newToken),
            ]);
        } catch (JWTException $e) {
            return response()->json([
                'status'  => 'error',
                'message' => 'Failed to refresh token',
                'error'   => $e->getMessage()
            ], 401);
        }
    }

    /**
     * Get user profile
     */
    public function me()
    {
        try {
            $user = JWTAuth::parseToken()->authenticate();

            return response()->json([
                'status'  => 'success',
                'message' => 'User profile fetched',
                'data'    => $user
            ]);
        } catch (JWTException $e) {
            return response()->json([
                'status'  => 'error',
                'message' => 'Token is invalid or expired',
                'error'   => $e->getMessage()
            ], 401);
        }
    }

    /**
     * Helper: format token response
     */
    protected function respondWithToken($token)
    {
        return [
            'access_token' => $token,
            'token_type'   => 'bearer',
            'expires_in'   => JWTAuth::factory()->getTTL() * 60, // dalam detik
        ];
    }
}

1. register(Request $request)

Fungsi ini bertugas untuk mendaftarkan user baru.

• Pertama, datanya divalidasi (nama wajib ada, email harus unik, password minimal 6 karakter dan harus dikonfirmasi).
• Jika validasi gagal → kembalikan respons JSON dengan pesan error.
• Jika lolos validasi → buat user baru di database (password di-hash).
• Setelah itu, langsung dibuatkan token JWT untuk user tersebut.
• Terakhir, kirim respons JSON berisi detail user dan token.

Intinya, function ini membuat user baru sekaligus memberikan token agar user bisa langsung login otomatis setelah registrasi.

2. login(Request $request)

Fungsi ini untuk mengautentikasi user.

• Ambil email dan password dari request.
• Coba cocokkan kredensial dengan JWTAuth::attempt().
• Jika gagal → artinya email atau password salah → kembalikan error 401 (Unauthorized).
• Jika berhasil → JWT akan mengembalikan token.
• Lalu token dikirim ke user dalam bentuk JSON response.

Dengan kata lain, login berfungsi untuk menukar email + password menjadi sebuah token JWT.

3. logout()

Fungsi ini untuk mengakhiri sesi user.

• JWTAuth::invalidate() dipanggil agar token yang sedang dipakai tidak berlaku lagi.
• Jika berhasil → user dianggap logout.
• Jika gagal (misalnya token tidak valid/expired) → kirim error response.

Jadi, logout di JWT itu bukan “hapus session” (karena kita tidak pakai session), tapi lebih ke membuat token yang sedang dipakai menjadi tidak sah lagi.

4. refresh()

Fungsi ini untuk memperbarui token.

• Token lama yang masih valid tetapi hampir kadaluarsa bisa diganti dengan token baru.
• Caranya pakai JWTAuth::refresh().
• Jika berhasil → kembalikan token baru ke user.
• Jika gagal (misalnya token sudah kadaluarsa total atau tidak valid) → kembalikan error 401.

Ini seperti “perpanjangan masa aktif token”, tanpa harus login ulang.

5. me()

Fungsi ini untuk mengambil profil user yang sedang login.

• Token yang dikirim oleh user diparsing dengan JWTAuth::parseToken()->authenticate().
• Jika valid → kembalikan data user.
• Jika token tidak valid/expired → kembalikan error 401.

Fungsi ini sangat berguna ketika kita ingin tahu “siapa user yang sedang memanggil API”.

6. respondWithToken($token)

Fungsi helper untuk merapikan format respons token.

• Token dikembalikan dalam bentuk:

  {
    "access_token": "....",
    "token_type": "bearer",
    "expires_in": 3600
  }
  

• expires_in dihitung otomatis dari konfigurasi TTL (time to live) di JWT (biasanya dalam menit, lalu dikali 60 biar jadi detik).

Dengan helper ini, semua fungsi (login, register, refresh) bisa menggunakan format yang konsisten.

Kesimpulan

Pada bagian ini, kita sudah membuat AuthController untuk mengatur seluruh alur autentikasi berbasis JWT. Berikut ringkasannya:

• register → membuat user baru dan langsung memberikan token.
• login → menukar kombinasi email + password menjadi token JWT.
• logout → membuat token yang sedang dipakai menjadi tidak valid.
• refresh → memperpanjang masa berlaku token tanpa login ulang.
• me → mengambil data user berdasarkan token yang dikirim.
• respondWithToken → membantu merapikan format respons token agar konsisten.

Dengan adanya controller ini, kita sudah siap untuk melanjutkan ke tahap berikutnya, yaitu mengatur rute API agar fungsi-fungsi autentikasi ini bisa dipanggil oleh client.