Tutorial Laravel 12: Model, Migration, Seeder, Factory, Auth Sanctum, API, Postman

Laravel terus berkembang dengan fitur-fitur baru yang memudahkan pengembang dalam membangun aplikasi. Dengan dirilisnya Laravel 12, framework ini semakin optimal untuk membangun sistem manajemen konten (CMS) dan API backend. Berbagai pembaruan telah diterapkan agar proses pengembangan menjadi lebih cepat, efisien, dan sesuai dengan standar industri.

Bagi para developer yang ingin membuat aplikasi berbasis web atau API dengan struktur yang rapi dan mudah dipelihara, Laravel 12 menjadi pilihan yang sangat menarik.

Mempelajari Laravel 12 sebagai Backend Developer

Pada artikel ini, kita akan mempelajari dasar-dasar coding Laravel 12 sebagai seorang backend developer. Fokus utama kita adalah memahami bagaimana framework ini digunakan untuk menangani berbagai aspek backend, seperti pengelolaan database, autentikasi pengguna, dan pengembangan API.

Jika Anda ingin membangun sistem yang scalable dan mudah diintegrasikan dengan berbagai layanan lain, Laravel 12 menyediakan banyak fitur bawaan yang akan sangat membantu. Mari kita mulai perjalanan belajar Laravel 12 dengan memahami konsep-konsep dasarnya!

Membuat Proyek Laravel 12 Tanpa Starter Kit dan Konfigurasi Database MySQL

Untuk memulai proyek Laravel 12 tanpa menggunakan starter kit, pastikan Anda sudah menginstal Composer dan memiliki PHP versi terbaru. Berikut adalah langkah-langkahnya.

1. Membuat Proyek Laravel 12

Gunakan perintah berikut di terminal atau command prompt untuk membuat proyek baru:

composer create-project laravel/laravel my-laravel12-app

Perintah ini akan mengunduh dan menginstal Laravel 12 ke dalam folder my-laravel12-app. Setelah proses selesai, masuk ke dalam direktori proyek:

cd my-laravel12-app

2. Mengatur File .env untuk Koneksi Database

Buka file .env yang ada di root proyek dan ubah bagian konfigurasi database sesuai dengan pengaturan MySQL yang Anda gunakan. Contohnya:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=nama_database
DB_USERNAME=root
DB_PASSWORD=yourpassword

Jika Anda belum memiliki database, buat database baru dengan perintah SQL berikut di MySQL:

CREATE DATABASE nama_database;

Pastikan nama database di .env sama dengan yang Anda buat.

3. Menjalankan Migrasi Database

Setelah konfigurasi database selesai, jalankan perintah berikut untuk membuat tabel-tabel default Laravel:

php artisan migrate

Jika terjadi error karena database belum terkoneksi dengan baik, pastikan MySQL berjalan dan periksa kembali pengaturan di file .env.

4. Menjalankan Proyek Laravel

Untuk menjalankan aplikasi Laravel, gunakan perintah berikut:

php artisan serve

Setelah perintah ini dijalankan, Anda bisa mengakses aplikasi Laravel melalui browser di alamat:

<http://127.0.0.1:8000>

Dengan langkah-langkah di atas, proyek Laravel 12 sudah siap digunakan tanpa menggunakan starter kit. Anda bisa langsung mulai mengembangkan fitur sesuai kebutuhan.

Membuat Model dan Migration Menggunakan Artisan

Dalam Laravel, model dan migration digunakan untuk mengelola struktur database dengan lebih mudah. Berikut adalah cara membuat model dan migration untuk tabel Category, Course, dan User.

1. Membuat Model dan Migration

Gunakan perintah berikut untuk membuat model beserta file migration-nya:

php artisan make:model Category -m
php artisan make:model Course -m
php artisan make:model User -m

Opsi -m akan membuat file migration secara otomatis untuk setiap model.

2. Menyesuaikan Migration

Buka file migration yang ada di folder database/migrations dan edit sesuai kebutuhan.

Migration untuk Category

Buka file migration dengan nama yang mengandung create_categories_table dan ubah menjadi seperti berikut:

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('categories', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->text('description')->nullable();
            $table->timestamps();
        });
    }

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

Migration untuk Course

Buka file migration dengan nama yang mengandung create_courses_table dan ubah menjadi seperti berikut:

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('courses', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('description')->nullable();
            $table->unsignedBigInteger('category_id');
            $table->timestamps();

            $table->foreign('category_id')->references('id')->on('categories')->onDelete('cascade');
        });
    }

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

Migration untuk User

Buka file migration dengan nama yang mengandung create_users_table dan ubah menjadi seperti berikut:

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 semua file migration selesai diedit, jalankan perintah berikut untuk mengeksekusi migration dan membuat tabel di database:

php artisan migrate

Jika berhasil, tabel categories, courses, dan users akan dibuat dalam database.

4. Menyesuaikan Model

Setelah tabel dibuat, sesuaikan model masing-masing agar mendukung hubungan antar tabel.

Model Category

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

namespace App\\Models;

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

class Category extends Model
{
    use HasFactory;

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

    public function courses()
    {
        return $this->hasMany(Course::class);
    }
}

Model Course

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

namespace App\\Models;

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

class Course extends Model
{
    use HasFactory;

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

    public function category()
    {
        return $this->belongsTo(Category::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'];
}

Dengan langkah-langkah di atas, model dan migration untuk Category, Course, dan User sudah siap digunakan dalam proyek Laravel 12.

Membuat Seeder dan Factory untuk Category, Courses, dan Users

Seeder dan Factory di Laravel memungkinkan pengisian data dummy ke database dengan cepat untuk keperluan testing atau development. Berikut adalah langkah-langkah implementasi untuk Category, Courses, dan Users.

1. Membuat Factory

Gunakan perintah berikut untuk membuat factory untuk masing-masing tabel:

php artisan make:factory CategoryFactory --model=Category
php artisan make:factory CourseFactory --model=Course
php artisan make:factory UserFactory --model=User

Buka file database/factories/CategoryFactory.php dan sesuaikan dengan kode berikut:

namespace Database\\Factories;

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

class CategoryFactory extends Factory
{
    protected $model = Category::class;

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

Buka file database/factories/CourseFactory.php dan sesuaikan dengan kode berikut:

namespace Database\\Factories;

use App\\Models\\Course;
use App\\Models\\Category;
use Illuminate\\Database\\Eloquent\\Factories\\Factory;

class CourseFactory extends Factory
{
    protected $model = Course::class;

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

Buka file database/factories/UserFactory.php dan sesuaikan dengan kode berikut:

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 CategorySeeder
php artisan make:seeder CourseSeeder
php artisan make:seeder UserSeeder

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

namespace Database\\Seeders;

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

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

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

namespace Database\\Seeders;

use Illuminate\\Database\\Seeder;
use App\\Models\\Course;
use App\\Models\\Category;

class CourseSeeder extends Seeder
{
    public function run()
    {
        Course::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

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

php artisan migrate:fresh --seed

Dengan langkah-langkah ini, Seeder dan Factory telah dibuat untuk Category, Courses, dan Users, sehingga data dummy dapat dihasilkan dengan cepat untuk testing dan development.

Menerapkan Service Repository Pattern untuk Categories

Service Repository Pattern membantu dalam memisahkan logika bisnis dari controller, sehingga kode lebih bersih dan mudah dipelihara. Berikut adalah cara penerapannya untuk Categories di Laravel 12.

1. Membuat Repository

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

namespace App\\Repositories;

use App\\Models\\Category;

class CategoryRepository
{
    public function getAll()
    {
        return Category::all();
    }

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

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

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

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

2. Membuat Service

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

namespace App\\Services;

use App\\Repositories\\CategoryRepository;

class CategoryService
{
    protected $categoryRepository;

    public function __construct(CategoryRepository $categoryRepository)
    {
        $this->categoryRepository = $categoryRepository;
    }

    public function getAllCategories()
    {
        return $this->categoryRepository->getAll();
    }

    public function getCategoryById($id)
    {
        return $this->categoryRepository->findById($id);
    }

    public function createCategory($data)
    {
        return $this->categoryRepository->create($data);
    }

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

    public function deleteCategory($id)
    {
        return $this->categoryRepository->delete($id);
    }
}

3. Membuat Controller

Gunakan perintah berikut untuk membuat controller:

php artisan make:controller CategoryController

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

namespace App\\Http\\Controllers;

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

class CategoryController extends Controller
{
    protected $categoryService;

    public function __construct(CategoryService $categoryService)
    {
        $this->categoryService = $categoryService;
    }

    public function index()
    {
        return response()->json($this->categoryService->getAllCategories());
    }

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

        return response()->json($this->categoryService->createCategory($data));
    }

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

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

        return response()->json($this->categoryService->updateCategory($id, $data));
    }

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

4. Menambahkan Route

Buka file routes/api.php dan tambahkan kode berikut untuk mengakses data kategori melalui API:

use App\\Http\\Controllers\\CategoryController;

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

5. Testing API

Gunakan tool seperti Postman atau cURL untuk menguji API ini:

• Mendapatkan semua kategori GET <http://127.0.0.1:8000/api/categories>
• Membuat kategori baru POST <http://127.0.0.1:8000/api/categories> Content-Type: application/json { "name": "Web Development", "description": "Kategori kursus untuk pengembangan web" }
• Mendapatkan kategori berdasarkan ID GET <http://127.0.0.1:8000/api/categories/1>
• Mengupdate kategori PUT <http://127.0.0.1:8000/api/categories/1> Content-Type: application/json { "name": "Updated Web Development", "description": "Kategori kursus yang telah diperbarui" }
• Menghapus kategori DELETE <http://127.0.0.1:8000/api/categories/1>

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

Menerapkan Service Repository Pattern untuk Courses

Service Repository Pattern memisahkan logika bisnis dari controller, sehingga kode lebih terstruktur, mudah dipelihara, dan dapat digunakan kembali. Berikut adalah implementasi lengkap untuk Courses di Laravel 12.

1. Membuat Repository

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

namespace App\\Repositories;

use App\\Models\\Course;

class CourseRepository
{
    public function getAll()
    {
        return Course::with('category')->get();
    }

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

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

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

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

2. Membuat Service

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

namespace App\\Services;

use App\\Repositories\\CourseRepository;

class CourseService
{
    protected $courseRepository;

    public function __construct(CourseRepository $courseRepository)
    {
        $this->courseRepository = $courseRepository;
    }

    public function getAllCourses()
    {
        return $this->courseRepository->getAll();
    }

    public function getCourseById($id)
    {
        return $this->courseRepository->findById($id);
    }

    public function createCourse($data)
    {
        return $this->courseRepository->create($data);
    }

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

    public function deleteCourse($id)
    {
        return $this->courseRepository->delete($id);
    }
}

3. Membuat Controller

Gunakan perintah berikut untuk membuat controller:

php artisan make:controller CourseController

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

namespace App\\Http\\Controllers;

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

class CourseController extends Controller
{
    protected $courseService;

    public function __construct(CourseService $courseService)
    {
        $this->courseService = $courseService;
    }

    public function index()
    {
        return response()->json($this->courseService->getAllCourses());
    }

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

        return response()->json($this->courseService->createCourse($data));
    }

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

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

        return response()->json($this->courseService->updateCourse($id, $data));
    }

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

4. Menambahkan Route

Buka file routes/api.php dan tambahkan kode berikut untuk mengakses data Courses melalui API:

use App\\Http\\Controllers\\CourseController;

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

5. Testing API

Gunakan tool seperti Postman atau cURL untuk menguji API ini:

• Mendapatkan semua courses GET <http://127.0.0.1:8000/api/courses>
• Membuat course baru POST <http://127.0.0.1:8000/api/courses> Content-Type: application/json { "title": "Belajar Laravel", "description": "Kursus Laravel untuk pemula", "category_id": 1 }
• Mendapatkan course berdasarkan ID GET <http://127.0.0.1:8000/api/courses/1>
• Mengupdate course PUT <http://127.0.0.1:8000/api/courses/1> Content-Type: application/json { "title": "Updated Laravel Course", "description": "Kursus Laravel dengan materi lebih lengkap", "category_id": 1 }
• Menghapus course DELETE <http://127.0.0.1:8000/api/courses/1>

Dengan langkah-langkah ini, Service Repository Pattern telah diterapkan untuk Courses, 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

Laravel Sanctum memungkinkan autentikasi API yang ringan dan sederhana. Berikut adalah cara implementasi autentikasi menggunakan Sanctum dan membatasi akses ke Categories CRUD agar hanya bisa diakses oleh pengguna yang sudah login.

1. Instalasi Laravel Sanctum

Jalankan perintah berikut untuk menginstal Sanctum:

composer require laravel/sanctum

Publikasikan konfigurasi Sanctum:

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

Jalankan migrasi untuk membuat tabel personal_access_tokens:

php artisan migrate

Tambahkan HasApiTokens ke dalam model User di app/Models/User.php:

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'];
}

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

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

Buka file routes/api.php dan ubah menjadi seperti berikut:

use App\\Http\\Controllers\\AuthController;
use App\\Http\\Controllers\\CategoryController;
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('/categories', [CategoryController::class, 'index']);
    Route::post('/categories', [CategoryController::class, 'store']);
    Route::get('/categories/{id}', [CategoryController::class, 'show']);
    Route::put('/categories/{id}', [CategoryController::class, 'update']);
    Route::delete('/categories/{id}', [CategoryController::class, 'destroy']);
});

4. Uji Coba API Menggunakan Postman

Register User

• Method: POST
• URL: 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" }

Login User

• Method: POST
• URL: http://127.0.0.1:8000/api/login
• Headers: Content-Type: application/json
• Body (JSON): { "email": "[email protected]", "password": "password123" }
• Response: { "token": "generated_token_here" }

Mencoba Akses CRUD Categories Tanpa Login

• Method: GET
• URL: http://127.0.0.1:8000/api/categories
• Response: { "message": "Unauthenticated." }

Akses CRUD Categories dengan Token

• Tambahkan Header:
  • Authorization: Bearer generated_token_here
• Mendapatkan Semua Categories
  • Method: GET
  • URL: http://127.0.0.1:8000/api/categories
• Menambahkan Category Baru
  • Method: POST
  • URL: http://127.0.0.1:8000/api/categories
  • Body (JSON): { "name": "Programming", "description": "Kategori untuk kursus pemrograman" }
• Mengupdate Category
  • Method: PUT
  • URL: http://127.0.0.1:8000/api/categories/1
  • Body (JSON): { "name": "Updated Programming", "description": "Kategori pemrograman terbaru" }
• Menghapus Category
  • Method: DELETE
  • URL: http://127.0.0.1:8000/api/categories/1

Logout User

• Method: POST
• URL: http://127.0.0.1:8000/api/logout
• Response: { "message": "Logged out" }

Setelah logout, jika mencoba akses Categories CRUD lagi tanpa login, API akan mengembalikan pesan "Unauthenticated."

Dengan langkah-langkah ini, Sanctum API Authentication telah diterapkan, dan akses ke Categories CRUD telah diamankan sehingga hanya pengguna yang login yang bisa mengaksesnya.

Kesimpulan yang Telah Dipelajari pada Artikel Ini

1. Laravel Sanctum untuk API Authentication Laravel Sanctum digunakan untuk mengelola autentikasi berbasis token, memungkinkan pengguna untuk melakukan login, mendapatkan token akses, dan mengamankan API hanya untuk pengguna yang sudah terautentikasi.
2. Implementasi Service Repository Pattern Dengan menerapkan Service Repository Pattern, logika bisnis dipisahkan dari controller, sehingga kode menjadi lebih modular, mudah dikelola, dan dapat digunakan kembali.
3. Membatasi Akses API dengan Middleware Auth Middleware auth:sanctum digunakan untuk melindungi endpoint API, sehingga hanya pengguna yang telah login yang bisa mengakses CRUD Categories, sementara pengguna yang tidak terautentikasi akan mendapatkan pesan "Unauthenticated."
4. Pengujian API dengan Postman Setiap endpoint diuji menggunakan Postman, termasuk:
   • Register dan login untuk mendapatkan token.
   • Menggunakan token untuk mengakses Categories CRUD.
   • Logout dan mencoba kembali mengakses API tanpa login untuk memastikan proteksi berjalan dengan baik.
5. Pengelolaan User Authentication dan Logout
   • Saat pengguna login, Laravel Sanctum menghasilkan personal access token yang digunakan untuk mengakses API.
   • Logout akan menghapus semua token aktif pengguna, sehingga akses API menjadi tidak valid hingga pengguna login kembali.

Dengan penerapan Laravel Sanctum dan Service Repository Pattern, API menjadi lebih aman, terstruktur, dan mudah dipelihara untuk proyek-proyek berbasis backend Laravel.

Penutup dan Saran

Membangun API yang aman dan terstruktur dengan Laravel tidak hanya membutuhkan pemahaman tentang framework itu sendiri, tetapi juga penerapan praktik terbaik seperti Service Repository Pattern dan Sanctum Authentication. Dengan menerapkan metode ini, kita bisa membuat aplikasi yang lebih scalable, mudah dipelihara, dan siap untuk produksi.

Namun, belajar sendiri terkadang bisa membingungkan dan memakan waktu. Untuk itu, bagi para web developer yang ingin meningkatkan skill mereka secara lebih efektif, belajar bersama mentor expert di BuildWithAngga adalah pilihan yang tepat.

Di BuildWithAngga, Anda bisa mendapatkan berbagai benefit eksklusif, seperti:

✅ Akses Materi Seumur Hidup – Belajar kapan saja tanpa batasan waktu.

✅ Sertifikat Kelulusan – Sebagai bukti keahlian untuk meningkatkan kredibilitas Anda.

✅ Portfolio Berkualitas – Membangun proyek nyata yang bisa menjadi modal utama untuk mendapatkan pekerjaan impian.

Jangan ragu untuk terus mengembangkan skill Anda bersama mentor terbaik! 🚀