Laravel 12 A-Z API: Model, Migrasi, Seeder, Factory, Autentikasi Sanctum, dan Uji Coba Postman

Name: Laravel 12 A-Z API: Model, Migrasi, Seeder, Factory, Autentikasi Sanctum, dan Uji Coba Postman
Brand: BuildWithAngga
Rating: 4.8 (9567 reviews)

December 05, 2025

•

Code

Laravel 12 A-Z API: Model, Migrasi, Seeder, Factory, Autentikasi Sanctum, dan Uji Coba Postman

Untuk kalian yang ingin membuat aplikasi atau sistem website, ada kabar baik: 'alat' pembuatnya, Laravel, baru saja rilis versi 12. Kalian bisa bayangkan Laravel 12 ini sebagai perangkat canggih yang membuat proses membangun segala macam hal, mulai dari website besar (CMS) hingga sistem data belakang layar (API), jadi jauh lebih cepat, efisien, dan hasilnya rapi sekali.

Ini adalah pilihan to the point yang sangat menarik agar hasil kerja kalian terstruktur dan mudah dipelihara.

Menguasai Laravel 12 untuk Peran Backend Developer

Nah, sekarang kita akan langsung belajar dasar-dasar menggunakan Laravel 12 ini. Intinya, kalian akan tahu cara mengurus semua hal yang terjadi di belakang layar:

mulai dari bagaimana menyimpan dan mengatur data-data penting, memastikan hanya orang yang benar yang bisa login, sampai membuat 'jembatan' khusus (API) agar sistem kalian bisa ngobrol dengan aplikasi lain.

Jadi, kalau kalian mau sistemnya bisa tumbuh besar dan gampang disambungkan ke mana-mana, kita akan pelajari semua konsep pentingnya sekarang juga!

Membuat Proyek Laravel 12 Tanpa Starter Kit dan Konfigurasi Database MySQL

Agar kita bisa mulai 'merakit' proyek Laravel 12 kalian dari nol, pastikan dulu alat wajibnya, yaitu Composer dan PHP versi paling baru, sudah kalian pasang di komputer.

1. Memulai Proyek Awal Laravel 12

Sekarang, kita 'panggil' perintah ini di command prompt atau terminal kalian untuk langsung menciptakan proyek baru kita!

composer create-project laravel/laravel tegar-bwa-app

Begitu perintah selesai, semua 'bahan' Laravel 12 kalian akan terpasang di folder proyek, dan kalian harus segera masuk ke dalamnya untuk memulai langkah berikutnya.

cd tegar-bwa-app

2. Konfigurasi Database di `.env`

Untuk langkah koneksi, kalian tinggal buka file .env di folder utama proyek dan ganti pengaturannya agar bisa terhubung dengan database MySQL milik kalian.

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE= tegar-bwa-database
DB_USERNAME=root
DB_PASSWORD=yourpassword

Tapi, kalau kalian belum punya tempat penyimpanan data (database) yang siap, kalian harus membuatnya dulu di MySQL dengan mengetik perintah khusus.

CREATE DATABASE tegar-bwa-database;

Cek dua kali: nama database di catatan rahasia .env itu harus sama lho dengan nama database yang barusan kalian bikin!

3. Eksekusi Migrasi Database (Running Migrations)

Karena databasenya sudah terhubung, mari kita jalankan satu perintah lagi untuk otomatis menciptakan semua tempat penyimpanan data utama proyek kalian.

php artisan migrate

Jangan panik kalau prosesnya berhenti karena masalah koneksi data, kalian cukup pastikan 'mesin' MySQL kalian sudah menyala dan cek ulang semua pengaturan di file rahasia .env itu.

4. Peluncuran Proyek Laravel

Agar aplikasi kalian langsung terlihat di browser, jalankan saja perintah sederhana ini.

php artisan serve

Keren! Sekarang kalian tinggal buka browser dan langsung lihat hasil kerja kalian di alamat ajaib ini: http://127.0.0.1:8000

Nah, karena semua langkah awal sudah selesai, kalian sekarang punya kanvas kosong Laravel 12 dan siap untuk mulai membuat fiturnya sendiri!

Membuat Model dan Migration Menggunakan Artisan

Kunci agar struktur database kalian rapi adalah dengan Model dan Migration, dan sekarang kalian akan belajar cara membuat 'cetak biru' untuk tabel Department**,** Training**, dan** User.

1. Membuat Model dan Migration

Sekarang, untuk membuat 'arsitek' data (Model) dan 'denah' bangunannya (Migration) secara instan, kalian hanya perlu mengetik perintah berikut.

php artisan make:model Department -m
php artisan make:model Training -m
php artisan make:model User -m

Kalian akan menjalankan perintah yang sama sebanyak tiga kali ini untuk menciptakan 'arsitek' dan 'denah' yang dibutuhkan untuk data Department**,** Training**, dan** User.

2. Menyesuaikan Migration

Langsung saja cari file 'denah' (Migration) tadi di dalam folder database untuk kita ubah dan rancang ulang strukturnya sesuai kebutuhan.

Migration untuk Department

Sekarang, temukan dan buka 'cetak biru' yang berlabel create_departments_table, lalu kita kustomisasi isinya.

use Illuminate\\Database\\Migrations\\Migration;
use Illuminate\\Database\\Schema\\Blueprint;
use Illuminate\\Support\\Facades\\Schema;

return new class extends Migration {
    public function up()
    {
        Schema::create('departments', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->text('description')->nullable();
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('departments');
    }
};

Migration untuk Training

Sekarang, temukan dan buka 'cetak biru' yang berlabel create_trainings_table, lalu kita kustomisasi isinya.

use Illuminate\\Database\\Migrations\\Migration;
use Illuminate\\Database\\Schema\\Blueprint;
use Illuminate\\Support\\Facades\\Schema;

return new class extends Migration {
    public function up()
    {
        Schema::create('trainings', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('description')->nullable();
            $table->unsignedBigInteger('department_id');
            $table->timestamps();

            $table->foreign('department_id')->references('id')->on('departments')->onDelete('cascade');
        });
    }

    public function down()
    {
        Schema::dropIfExists('trainings');
    }
};

Migration untuk User

Sekarang, temukan dan buka 'cetak biru' yang berlabel create_users_table, lalu kita kustomisasi isinya.

use Illuminate\\Database\\Migrations\\Migration;
use Illuminate\\Database\\Schema\\Blueprint;
use Illuminate\\Support\\Facades\\Schema;

return new class extends Migration {
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->string('password');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('users');
    }
};

3. Menjalankan Migration

Setelah Migration files siap, kalian eksekusi perintah Artisan ini untuk me-migrate seluruh skema database yang telah kalian definisikan.

php artisan migrate:fresh

Dengan schema deployment yang sukses, tabel entitas departments, trainings, dan users secara definitif telah terbentuk dalam Database Instance kalian.

4. Menyesuaikan Model

Nah, sekarang tabelnya sudah ada, yuk kita define Eloquent relationships di setiap Model biar semua tabel kalian bisa saling terhubung!

Model Department

Buka file app/Models/Department.php dan ubah isinya menjadi:

namespace App\\Models;

use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;
use Illuminate\\Database\\Eloquent\\Model;

class Department extends Model
{
    use HasFactory;

    protected $fillable = ['name', 'description'];

    public function trainings()
    {
        return $this->hasMany(Training::class);
    }
}

Model Training

Buka file app/Models/Training.php dan ubah isinya menjadi:

namespace App\\Models;

use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;
use Illuminate\\Database\\Eloquent\\Model;

class Training extends Model
{
    use HasFactory;

    protected $fillable = ['title', 'description', 'department_id'];

    public function department()
    {
        return $this->belongsTo(Department::class);
    }
}

Model User

Buka file app/Models/User.php dan pastikan isinya seperti berikut:

namespace App\\Models;

use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;
use Illuminate\\Foundation\\Auth\\User as Authenticatable;
use Illuminate\\Notifications\\Notifiable;

class User extends Authenticatable
{
    use HasFactory, Notifiable;

    protected $fillable = ['name', 'email', 'password'];
}

Oke guys, dengan ini Model dan Migration untuk tiga entity utama di Laravel 12 kalian berhasil dikonfigurasi. Next step, kita isi data!

Membuat Seeder dan Factory untuk Department, Training, dan Users

Waktunya mengisi data palsu! Kalian akan setup Factory dan Seeder agar data dummy buat Category, Course, dan User bisa inject ke database dengan instan.

1. Membuat Factory

Sekarang, coba kalian jalankan perintah ini biar pencetak data palsu (Factory) untuk tiap tabel kita langsung jadi.

php artisan make:factory DepartmentFactory --model=Department
php artisan make:factory TrainingFactory --model=Training
php artisan make:factory UserFactory --model=User

Yuk kita custom Factory si Department (DepartmentFactory.php) ini, biar data palsu yang dihasilkan sesuai dengan kebutuhan kita.

namespace Database\\Factories;

use App\\Models\\Department;
use Illuminate\\Database\\Eloquent\\Factories\\Factory;

class DepartmentFactory extends Factory
{
    protected $model = Department::class;

    public function definition()
    {
        return [
            'name' => $this->faker->word(),
            'description' => $this->faker->sentence(),
        ];
    }
}

Yuk kita custom Factory si Department (TrainingFactory.php) ini, biar data palsu yang dihasilkan sesuai dengan kebutuhan kita.

namespace Database\\Factories;

use App\\Models\\Training;
use App\\Models\\Department;
use Illuminate\\Database\\Eloquent\\Factories\\Factory;

class TrainingFactory extends Factory
{
    protected $model = Training::class;

    public function definition()
    {
        return [
            'title' => $this->faker->sentence(),
            'description' => $this->faker->paragraph(),
            'department_id' => Department::factory(),
        ];
    }
}

Yuk kita custom Factory si Department (UserFactory.php) ini, biar data palsu yang dihasilkan sesuai dengan kebutuhan kita.

namespace Database\\Factories;

use App\\Models\\User;
use Illuminate\\Database\\Eloquent\\Factories\\Factory;
use Illuminate\\Support\\Str;

class UserFactory extends Factory
{
    protected $model = User::class;

    public function definition()
    {
        return [
            'name' => $this->faker->name(),
            'email' => $this->faker->unique()->safeEmail(),
            'email_verified_at' => now(),
            'password' => bcrypt('password'),
            'remember_token' => Str::random(10),
        ];
    }
}

2. Membuat Seeder

Gunakan perintah berikut untuk membuat seeder:

php artisan make:seeder DepartmentSeeder
php artisan make:seeder TrainingSeeder
php artisan make:seeder UserSeeder

Buka file database/seeders/DepartmentSeeder.php dan isi dengan kode berikut:

namespace Database\\Seeders;

use Illuminate\\Database\\Seeder;
use App\\Models\\Department;

class DepartmentSeeder extends Seeder
{
    public function run()
    {
        Department::factory()->count(10)->create();
    }
}

Buka file database/seeders/TrainingSeeder.php dan isi dengan kode berikut:

namespace Database\\Seeders;

use Illuminate\\Database\\Seeder;
use App\\Models\\Training;

class TrainingSeeder extends Seeder
{
    public function run()
    {
        Training::factory()->count(20)->create();
    }
}

Buka file database/seeders/UserSeeder.php dan isi dengan kode berikut:

namespace Database\\Seeders;

use Illuminate\\Database\\Seeder;
use App\\Models\\User;

class UserSeeder extends Seeder
{
    public function run()
    {
        User::factory()->count(5)->create();
    }
}

3. Memanggil Seeder di DatabaseSeeder

Buka file database/seeders/DatabaseSeeder.php dan tambahkan pemanggilan seeder berikut:

namespace Database\\Seeders;

use Illuminate\\Database\\Seeder;

class DatabaseSeeder extends Seeder
{
    public function run()
    {
        $this->call([
            UserSeeder::class,
            CategorySeeder::class,
            CourseSeeder::class,
        ]);
    }
}

4. Menjalankan Seeder

Jalankan perintah berikut untuk mengisi database dengan data dummy:

php artisan db:seed

Bila error tambahkan ini ke file database/factories/UserFactory.php

use App\\Models\\User;

Bila ingin mengosongkan database terlebih dahulu sebelum menjalankan seeder, gunakan perintah berikut:

php artisan migrate:fresh --seed

Mantap, kalian sudah berhasil membuat 'pabrik' data (Factory) dan 'penyebar' data (Seeder) untuk entitas Departments, Trainings, dan Users! Sekarang, kalian nggak perlu pusing lagi input data satu per satu, karena data palsu (dummy data) yang kalian butuhkan untuk testing dan development bisa dibuat otomatis secepat kilat.

Proyek kalian jadi langsung terisi dan siap diuji coba tanpa ribet.

Menerapkan Service Repository Pattern untuk Departments

Sekarang saatnya kalian upgrade cara coding kalian dengan Service Repository Pattern! Anggap saja ini adalah pembagian tugas agar kode kalian rapi kayak folder baru.

Controller hanya bertugas menerima perintah, sementara Logika Bisnis diurus di tempat lain. Intinya, kode kalian jadi bersih dan gampang di-maintain kalau ada perubahan. Yuk, kita terapkan pola keren ini untuk mengurus data Departments di Laravel 12.

1. Membuat Repository

Buat folder app/Repositories, lalu buat file DepartmentRepository.php di dalamnya:

namespace App\\Repositories;

use App\\Models\\Department;

class DepartmentRepository
{
    public function getAll()
    {
        return Department::all();
    }

    public function findById($id)
    {
        return Department::findOrFail($id);
    }

    public function create(array $data)
    {
        return Department::create($data);
    }

    public function update($id, array $data)
    {
        $department = Department::findOrFail($id);
        $department->update($data);
        return $department;
    }

    public function delete($id)
    {
        $department = Department::findOrFail($id);
        return $department->delete();
    }
}

2. Membuat Service

Buat folder app/Services, lalu buat file DepartmentService.php di dalamnya:

namespace App\\Services;

use App\\Repositories\\DepartmentRepository;

class DepartmentService
{
    protected $departmentRepository;

    public function __construct(DepartmentRepository $departmentRepository)
    {
        $this->departmentRepository = $departmentRepository;
    }

    public function getAllDepartments()
    {
        return $this->departmentRepository->getAll();
    }

    public function getDepartmentById($id)
    {
        return $this->departmentRepository->findById($id);
    }

    public function createDepartment($data)
    {
        return $this->departmentRepository->create($data);
    }

    public function updateDepartment($id, $data)
    {
        return $this->departmentRepository->update($id, $data);
    }

    public function deleteDepartment($id)
    {
        return $this->departmentRepository->delete($id);
    }
}

3. Membuat Controller

Gunakan perintah berikut untuk membuat controller:

php artisan make:controller DepartmentController

Buka file app/Http/Controllers/DepartmentController.php dan ubah isinya menjadi:

namespace App\\Http\\Controllers;

use App\\Services\\DepartmentService;
use Illuminate\\Http\\Request;

class DepartmentController extends Controller
{
    protected $departmentService;

    public function __construct(DepartmentService $departmentService)
    {
        $this->departmentService = $departmentService;
    }

    public function index()
    {
        return response()->json($this->departmentService->getAllDepartments());
    }

    public function store(Request $request)
    {
        $data = $request->validate([
            'name' => 'required|string|max:255',
            'description' => 'nullable|string'
        ]);

        return response()->json($this->departmentService->createDepartment($data));
    }

    public function show($id)
    {
        return response()->json($this->departmentService->getDepartmentById($id));
    }

    public function update(Request $request, $id)
    {
        $data = $request->validate([
            'name' => 'required|string|max:255',
            'description' => 'nullable|string'
        ]);

        return response()->json($this->departmentService->updateDepartment($id, $data));
    }

    public function destroy($id)
    {
        return response()->json(['deleted' => $this->departmentService->deleteDepartment($id)]);
    }
}

4. Menambahkan Route

Selanjutnya kalian buka file routes/api.php dan tambahkan kode berikut untuk mengakses data department melalui API:

use App\\Http\\Controllers\\DepartmentController;

Route::get('/departments', [DepartmentController::class, 'index']);
Route::post('/departments', [DepartmentController::class, 'store']);
Route::get('/departments/{id}', [DepartmentController::class, 'show']);
Route::put('/departments/{id}', [DepartmentController::class, 'update']);
Route::delete('/departments/{id}', [DepartmentController::class, 'destroy']);

5. Testing API

Sekarang waktunya menguji. Gunakan alat seperti Postman atau cURL untuk menguji endpoint API berikut:

Mendapatkan Semua Department (Read All)
- Metode: GET
- Endpoint: http://127.0.0.1:8000/api/departments
Membuat Department Baru (Create)
- Metode: POST
- Endpoint: http://127.0.0.1:8000/api/departments
- Header: Content-Type: application/json
- Body (Contoh): {"name": "Web Development", "description": "Kategori kursus untuk pengembangan web"}
Mendapatkan Department Berdasarkan ID (Read One)
- Metode: GET
- Endpoint: http://127.0.0.1:8000/api/departments/1 (Ganti 1 dengan ID department yang valid)
Mengupdate Department (Update)
- Metode: PUT
- Endpoint: http://127.0.0.1:8000/api/departments/1 (Ganti 1 dengan ID department yang valid)
- Header: Content-Type: application/json
- Body (Contoh): {"name": "Updated Web Development", "description": "Kategori kursus yang telah diperbarui"}
Menghapus Department (Delete)
- Metode: DELETE
- Endpoint: http://127.0.0.1:8000/api/departments/1 (Ganti 1 dengan ID department yang valid)

Dengan langkah-langkah ini, Service Repository Pattern telah diterapkan untuk tabel Departments, membuat kode lebih terstruktur dan mudah dipelihara.

Menerapkan Service Repository Pattern untuk Trainings

Sekarang saatnya kalian upgrade cara coding kalian dengan Service Repository Pattern! Anggap saja ini adalah pembagian tugas agar kode kalian rapi kayak folder baru.

1. Membuat Repository

Pada folder app/Repositories, lalu buat file TrainingRepository.php di dalamnya:

namespace App\\Repositories;

use App\\Models\\Training;

class TrainingRepository
{
    public function getAll()
    {
        return Training::with('department')->get();
    }

    public function findById($id)
    {
        return Training::with('department')->findOrFail($id);
    }

    public function create(array $data)
    {
        return Training::create($data);
    }

    public function update($id, array $data)
    {
        $training = Training::findOrFail($id);
        $training->update($data);
        return $training;
    }

    public function delete($id)
    {
        $training = Training::findOrFail($id);
        return $training->delete();
    }
}

2. Membuat Service

Pada folder app/Services, lalu buat file TrainingService.php di dalamnya:

namespace App\\Services;

use App\\Repositories\\TrainingRepository;

class TrainingService
{
    protected $trainingRepository;

    public function __construct(TrainingRepository $trainingRepository)
    {
        $this->trainingRepository = $trainingRepository;
    }

    public function getAllTrainings()
    {
        return $this->trainingRepository->getAll();
    }

    public function getTrainingById($id)
    {
        return $this->trainingRepository->findById($id);
    }

    public function createTraining($data)
    {
        return $this->trainingRepository->create($data);
    }

    public function updateTraining($id, $data)
    {
        return $this->trainingRepository->update($id, $data);
    }

    public function deleteTraining($id)
    {
        return $this->trainingRepository->delete($id);
    }
}

3. Membuat Controller

Gunakan perintah berikut untuk membuat controller:

php artisan make:controller TrainingController

Buka file app/Http/Controllers/TrainingController.php dan ubah isinya menjadi:

namespace App\\Http\\Controllers;

use App\\Services\\TrainingService;
use Illuminate\\Http\\Request;

class TrainingController extends Controller
{
    protected $trainingService;

    public function __construct(TrainingService $trainingService)
    {
        $this->trainingService = $trainingService;
    }

    public function index()
    {
        return response()->json($this->trainingService->getAllTrainings());
    }

    public function store(Request $request)
    {
        $data = $request->validate([
            'title' => 'required|string|max:255',
            'description' => 'nullable|string',
            'department_id' => 'required|exists:departments,id'
        ]);

        return response()->json($this->trainingService->createTraining($data));
    }

    public function show($id)
    {
        return response()->json($this->trainingService->getTrainingById($id));
    }

    public function update(Request $request, $id)
    {
        $data = $request->validate([
            'title' => 'required|string|max:255',
            'description' => 'nullable|string',
            'department_id' => 'required|exists:departments,id'
        ]);

        return response()->json($this->trainingService->updateTraining($id, $data));
    }

    public function destroy($id)
    {
        return response()->json(['deleted' => $this->trainingService->deleteTraining($id)]);
    }
}

4. Menambahkan Route

Selanjutnya kalian buka file routes/api.php dan tambahkan kode berikut untuk mengakses data department melalui API:

use App\\Http\\Controllers\\TrainingController;

Route::get('/trainings', [TrainingController::class, 'index']);
Route::post('/trainings', [TrainingController::class, 'store']);
Route::get('/trainings/{id}', [TrainingController::class, 'show']);
Route::put('/trainings/{id}', [TrainingController::class, 'update']);
Route::delete('/trainings/{id}', [TrainingController::class, 'destroy']);

5. Testing API

Sekarang waktunya menguji. Gunakan alat seperti Postman atau cURL untuk menguji endpoint API berikut:

Mendapatkan Semua Training (Read All)
- Metode: GET
- Endpoint: http://127.0.0.1:8000/api/trainings
Membuat Training Baru (Create)
- Metode: POST
- Endpoint: http://127.0.0.1:8000/api/trainings
- Header: Content-Type: application/json
- Body (Contoh): {"title": "Belajar Laravel", "description": "Kursus Laravel untuk pemula", "department_id": 1}
Mendapatkan Training Berdasarkan ID (Read One)
- Metode: GET
- Endpoint: http://127.0.0.1:8000/api/trainings/1 (Ganti 1 dengan ID training yang valid)
Mengupdate Training (Update)
- Metode: PUT
- Endpoint: http://127.0.0.1:8000/api/trainings/1 (Ganti 1 dengan ID training yang valid)
- Header: Content-Type: application/json
- Body (Contoh): {"title": "Updated Laravel Training", "description": "Training Laravel dengan materi lebih lengkap", "department_id": 1}
Menghapus Training (Delete)
- Metode: DELETE
- Endpoint: http://127.0.0.1:8000/api/trainings/1 (Ganti 1 dengan ID training yang valid)

Dengan langkah-langkah ini, Service Repository Pattern telah diterapkan untuk Trainings , membuat kode lebih modular, terstruktur, dan mudah dipelihara.

Menerapkan Authentication Sanctum API di Laravel 12 dan Membungkus Categories CRUD agar Hanya Bisa Diakses Setelah Login

Sekarang kita pasang 'satpam' di API kalian menggunakan Laravel Sanctum! Ini adalah cara paling ringan dan gampang untuk melakukan autentikasi, alias memastikan siapa yang boleh masuk.

Tujuannya jelas: kalian akan membatasi akses ke semua urusan CRUD Departments kalian agar HANYA pengguna yang sudah login yang bisa melihat atau mengubahnya. Yuk, kita kunci data ini!

1. Instalasi Laravel Sanctum

Kalian silahkan jalankan perintah berikut untuk menginstal Sanctum:

composer require laravel/sanctum

Jadikan publik konfigurasi Sanctum-nya:

php artisan vendor:publish --provider="Laravel\\Sanctum\\SanctumServiceProvider"

Lalu silahkan kalian jalankan migrasi untuk membuat tabel personal_access_tokens:

php artisan migrate

Lalu tambahkan HasApiTokens ke dalam model User di app/Models/User.php kalian ya:

namespace App\\Models;

use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;
use Illuminate\\Foundation\\Auth\\User as Authenticatable;
use Illuminate\\Notifications\\Notifiable;
use Laravel\\Sanctum\\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;

    protected $fillable = ['name', 'email', 'password'];
}

Lalu tambahkan middleware Sanctum di app/Http/Kernel.php pada bagian $middlewareGroups['api']:

protected $middlewareGroups = [
    'api' => [
        \\Laravel\\Sanctum\\Http\\Middleware\\EnsureFrontendRequestsAreStateful::class,
        'throttle:api',
        \\Illuminate\\Routing\\Middleware\\SubstituteBindings::class,
    ],
];

2. Membuat Controller untuk Authentication

Yuk kita membuat controller nya untuk authnya. Gunakan perintah berikut untuk membuat AuthController:

php artisan make:controller AuthController

Buka file app/Http/Controllers/AuthController.php dan tambahkan kode berikut:

namespace App\\Http\\Controllers;

use App\\Models\\User;
use Illuminate\\Http\\Request;
use Illuminate\\Support\\Facades\\Hash;
use Illuminate\\Validation\\ValidationException;

class AuthController extends Controller
{
    public function register(Request $request)
    {
        $request->validate([
            'name' => 'required|string|max:255',
            'email' => 'required|string|email|unique:users',
            'password' => 'required|string|min:8',
        ]);

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

        $token = $user->createToken('auth_token')->plainTextToken;

        return response()->json(['token' => $token], 201);
    }

    public function login(Request $request)
    {
        $request->validate([
            'email' => 'required|string|email',
            'password' => 'required|string',
        ]);

        $user = User::where('email', $request->email)->first();

        if (!$user || !Hash::check($request->password, $user->password)) {
            throw ValidationException::withMessages([
                'email' => ['The provided credentials are incorrect.'],
            ]);
        }

        $token = $user->createToken('auth_token')->plainTextToken;

        return response()->json(['token' => $token]);
    }

    public function logout(Request $request)
    {
        $request->user()->tokens()->delete();
        return response()->json(['message' => 'Logged out']);
    }
}

3. Membungkus Categories CRUD dalam Middleware Auth

Selanjutnya buka file routes/api.php dan lakukan perubahan hingga menjadi seperti berikut:

use App\\Http\\Controllers\\AuthController;
use App\\Http\\Controllers\\DepartmentController;
use Illuminate\\Support\\Facades\\Route;

// Routes untuk Authentication
Route::post('/register', [AuthController::class, 'register']);
Route::post('/login', [AuthController::class, 'login']);

// Routes yang membutuhkan autentikasi
Route::middleware('auth:sanctum')->group(function () {
    Route::post('/logout', [AuthController::class, 'logout']);

		Route::get('/departments', [DepartmentController::class, 'index']);
		Route::post('/departments', [DepartmentController::class, 'store']);
		Route::get('/departments/{id}', [DepartmentController::class, 'show']);
		Route::put('/departments/{id}', [DepartmentController::class, 'update']);
		Route::delete('/departments/{id}', [DepartmentController::class, 'destroy']);
});

4. Uji Coba API Menggunakan Postman

Mendaftarkan Pengguna (Register User)
- Metode: POST
- Endpoint: http://127.0.0.1:8000/api/register
- Headers: Content-Type: application/json
- Body (JSON): { "name": "John Doe", "email": "[email protected]", "password": "password123" }
- Response: { "token": "generated_token_here" }
Pengguna Masuk (Login User)
- Metode: POST
- Endpoint: http://127.0.0.1:8000/api/login
- Header: Content-Type: application/json
- Body (JSON): { "email": "[email protected]", "password": "password123" }
- Response: { "token": "generated_token_here" }
Mencoba Akses CRUD Categories Tanpa Login
- Metode: GET
- Endpoint: http://127.0.0.1:8000/api/categories
- Response: { "message": "Unauthenticated." }
Akses CRUD Departments dengan Token
- Tambahkan Header:
  - Authorization: Bearer generated_token_here
- Mendapatkan Semua Departments
  - Method: GET
  - URL: http://127.0.0.1:8000/api/departments
- Menambahkan Department Baru
  - Method: POST
  - URL: http://127.0.0.1:8000/api/departments
  - Body (JSON): { "name": "Programming", "description": "Kategori untuk kursus pemrograman" }
- Mengupdate Department
  - Method: PUT
  - URL: http://127.0.0.1:8000/api/departments/1
  - Body (JSON): { "name": "Updated Programming", "description": "Departemen pemrograman terbaru" }
- Menghapus Department
  - Method: DELETE
  - URL: http://127.0.0.1:8000/api/departments/1
Pengguna Keluar (Logout User)
- Metode: POST
- Endpoint: http://127.0.0.1:8000/api/logout
- Response: { "message": "Logged out" }

Selamat! Kalian sudah berhasil mengunci API kalian pakai Sanctum Authentication! Artinya, kalau ada yang iseng mencoba akses data CRUD Departments setelah logout, API kalian akan langsung menolak dengan pesan tegas "Unauthenticated." Ini membuktikan bahwa data Departemen kalian sudah aman dan hanya bisa diutak-atik oleh pengguna yang sudah verifikasi login.

Kesimpulan yang Telah Dipelajari pada Artikel Ini

Struktur dan Kerapian Kode

Gas! Hal pertama yang keren adalah kalian sudah membuat kode yang sangat rapi berkat Service Repository Pattern. Pola ini berfungsi sebagai pembagian tugas yang cermat, memastikan logika bisnis kalian terpisah jauh dari Controller; hasilnya, kode jadi lebih modular, gampang banget dikelola, dan enak dilihat saat kalian atau teman kalian mau melakukan perubahan.

Pengamanan Akses dengan Token Nah, setelah rapi, giliran keamanan! Kalian telah memasang Laravel Sanctum sebagai 'satpam' API utama yang bekerja menggunakan token rahasia. Caranya begini: saat kalian login, Sanctum akan memberikan personal access token yang menjadi kunci kalian untuk mengakses endpoint.

Kalau kalian logout, semua token itu langsung hangus, dan Middleware auth:sanctum akan memastikan bahwa siapa pun yang mencoba mengakses CRUD Categories tanpa token yang valid akan dibalas dengan pesan tegas "Unauthenticated."

Verifikasi dan Kesimpulan Akhir Dan yang paling penting: kalian sudah membuktikan semua mekanisme itu berjalan! Kalian pakai Postman untuk menguji coba seluruh alur, mulai dari meminta token, menggunakannya, sampai memverifikasi bahwa akses error saat token dihapus.

Dengan semua setup Sanctum dan Service Repository Pattern ini, API kalian nggak cuma aman, tapi juga terstruktur banget, menjadikan proyek backend Laravel kalian siap untuk tantangan besar.

Penutup dan Saran

Dengar baik-baik: Untuk jadi backend developer sejati, kalian nggak cukup hanya tahu dasar-dasar Laravel. Kalian wajib banget menguasai skill premium seperti Service Repository Pattern biar kode kalian rapi, plus Sanctum Authentication biar API kalian anti-bobol! Kalau kalian sudah menerapkan praktik terbaik ini, dijamin aplikasi kalian siap scaling dan siap kerja di mana pun.

Tapi, nggak bisa dipungkiri, belajar sendiri itu sering bikin pusing, trial and error, dan buang-buang waktu berbulan-bulan. Nah, daripada kalian stuck di masalah yang sama, BuildWithAngga punya solusi shortcut premium untuk kalian! Kami sediakan mentor expert yang akan membimbing kalian menguasai semua skill Laravel tingkat lanjut itu, mulai dari struktur kode sampai keamanan dengan cara yang paling efektif dan terstruktur.

Jadi, apa yang kalian dapatkan? Ini benefit eksklusifnya: Kalian akan dapat Akses Materi SEUMUR HIDUP yaitu benar-benar tanpa batas waktu.

Setelah lulus, kalian bawa pulang Sertifikat Kelulusan sebagai bukti keahlian kalian, dan yang paling penting, kalian bisa pamer Portfolio Berkualitas yang siap jadi modal utama buat dapat kerjaan impian! Tunggu apa lagi? Gas upgrade skill kalian sekarang! 🚀

Pelajari Selengkapnya

Ebook Laravel 12 Bikin Web Manajemen Gudang dan Point of Sale

(28)

Career Preparation

Bangun Karir Impian.
Dibantu Expert, Gratis 🤩

Stop buang waktu browsing sana-sini karena
di BuildWithAngga sudah tersedia arahan pasti

Chat ke CS Karir HandBook

Content Editor

Tegar Fauzan Firdaus

Tegar Fauzan Firdaus, an expert content writer at BuildWithAngga, continually acquires valuable knowledge in web technology, UI UX design, SEO, and business. This knowledge is shared freely with the extensive community in Indonesia.

Laravel 12 A-Z API: Model, Migrasi, Seeder, Factory, Autentikasi Sanctum, dan Uji Coba Postman

Menguasai Laravel 12 untuk Peran Backend Developer

Membuat Proyek Laravel 12 Tanpa Starter Kit dan Konfigurasi Database MySQL

1. Memulai Proyek Awal Laravel 12

2. Konfigurasi Database di .env

3. Eksekusi Migrasi Database (Running Migrations)

4. Peluncuran Proyek Laravel

Membuat Model dan Migration Menggunakan Artisan

1. Membuat Model dan Migration

2. Menyesuaikan Migration

Migration untuk Department

Migration untuk Training

Migration untuk User

3. Menjalankan Migration

4. Menyesuaikan Model

Model Department

Model Training

Model User

Membuat Seeder dan Factory untuk Department**,** Training**, dan Users**

1. Membuat Factory

2. Membuat Seeder

3. Memanggil Seeder di DatabaseSeeder

4. Menjalankan Seeder

Menerapkan Service Repository Pattern untuk Departments

1. Membuat Repository

2. Membuat Service

3. Membuat Controller

4. Menambahkan Route

5. Testing API

Menerapkan Service Repository Pattern untuk Trainings

1. Membuat Repository

2. Membuat Service

3. Membuat Controller

4. Menambahkan Route

5. Testing API

Menerapkan Authentication Sanctum API di Laravel 12 dan Membungkus Categories CRUD agar Hanya Bisa Diakses Setelah Login

1. Instalasi Laravel Sanctum

2. Membuat Controller untuk Authentication

3. Membungkus Categories CRUD dalam Middleware Auth

4. Uji Coba API Menggunakan Postman

Kesimpulan yang Telah Dipelajari pada Artikel Ini

Penutup dan Saran

Pelajari Selengkapnya

Content Editor

Explore More

Explore More

2. Konfigurasi Database di `.env`

Membuat Seeder dan Factory untuk Department, Training, dan Users