Laravel API: Membangun Backend Modern dengan Laravel

Laravel, framework PHP yang elegan dan kuat, telah menjadi pilihan utama bagi banyak developer dalam membangun aplikasi web modern. Salah satu kekuatan utama Laravel adalah kemampuannya dalam membangun Laravel API, yang memungkinkan aplikasi frontend (seperti React, Vue.js, atau bahkan aplikasi mobile) untuk berkomunikasi dengan backend melalui format data yang standar, seperti JSON. Dalam artikel ini, kita akan membahas secara mendalam tentang bagaimana membangun Laravel API yang modern dan efisien.

1. Mengapa Memilih Laravel untuk Membangun API?

Sebelum kita membahas lebih jauh tentang bagaimana membangun Laravel API, mari kita pahami terlebih dahulu mengapa Laravel menjadi pilihan yang tepat. Ada beberapa alasan kuat, di antaranya:

Eloquent ORM yang Mudah Digunakan: Eloquent ORM (Object Relational Mapper) memudahkan kita untuk berinteraksi dengan database. Kita tidak perlu menulis query SQL yang rumit; Eloquent menyediakan cara yang lebih intuitif dan berorientasi objek untuk melakukan operasi CRUD (Create, Read, Update, Delete).
Artisan Console yang Powerful: Artisan adalah command-line interface (CLI) bawaan Laravel yang menyediakan banyak perintah yang berguna untuk mempercepat proses pengembangan. Misalnya, kita bisa menggunakan Artisan untuk membuat controller, model, migration, dan lain sebagainya.
Middleware yang Fleksibel: Middleware memungkinkan kita untuk menambahkan lapisan logika sebelum atau sesudah request ditangani oleh aplikasi. Ini sangat berguna untuk melakukan otentikasi, otorisasi, validasi, dan tugas-tugas lainnya yang umum dalam membangun API.
Routing yang Ekspresif: Laravel menyediakan sistem routing yang sederhana dan ekspresif. Kita dapat dengan mudah mendefinisikan endpoint API dan menghubungkannya dengan controller yang sesuai.
Security yang Solid: Laravel memiliki fitur keamanan bawaan yang membantu kita melindungi aplikasi dari berbagai macam serangan, seperti SQL injection, cross-site scripting (XSS), dan cross-site request forgery (CSRF).
Dokumentasi yang Lengkap dan Komunitas yang Besar: Laravel memiliki dokumentasi yang sangat lengkap dan mudah dipahami. Selain itu, komunitas Laravel juga sangat besar dan aktif, sehingga kita dapat dengan mudah menemukan bantuan jika mengalami kesulitan.

Dengan semua keuntungan ini, tidak heran jika Laravel menjadi framework yang sangat populer untuk membangun Laravel API.

2. Persiapan Awal: Instalasi Laravel dan Konfigurasi Database

Langkah pertama dalam membangun Laravel API adalah dengan menginstal Laravel dan mengkonfigurasi database. Pastikan Anda sudah memiliki PHP dan Composer terinstal di sistem Anda.

Instalasi Laravel: Buka terminal Anda dan jalankan perintah berikut:
```
composer create-project --prefer-dist laravel/laravel nama-projek-api
cd nama-projek-api
```
Ganti nama-projek-api dengan nama proyek API yang Anda inginkan.
Konfigurasi Database: Buka file .env dan sesuaikan pengaturan database sesuai dengan konfigurasi database Anda. Contohnya:
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=nama_database
DB_USERNAME=nama_pengguna
DB_PASSWORD=kata_sandi
```
Pastikan Anda sudah membuat database yang sesuai di server database Anda.

Setelah mengkonfigurasi database, jalankan perintah berikut untuk membuat migration untuk tabel users:

php artisan migrate

3. Membuat Model dan Migration untuk Sumber Daya API

Setelah instalasi Laravel dan konfigurasi database selesai, langkah selanjutnya adalah membuat model dan migration untuk sumber daya (resources) API yang ingin kita kelola. Misalnya, kita ingin membuat API untuk mengelola data “Artikel”.

Membuat Model: Jalankan perintah berikut untuk membuat model Artikel:
```
php artisan make:model Artikel
```
Ini akan membuat file Artikel.php di direktori app/Models.

Membuat Migration: Jalankan perintah berikut untuk membuat migration untuk tabel artikels:

php artisan make:migration create_artikels_table

Ini akan membuat file migration di direktori database/migrations. Buka file migration tersebut dan definisikan struktur tabel artikels sesuai dengan kebutuhan Anda. Contohnya:

<?php

use IlluminateDatabaseMigrationsMigration;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateSupportFacadesSchema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('artikels', function (Blueprint $table) {
            $table->id();
            $table->string('judul');
            $table->text('isi');
            $table->string('penulis');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('artikels');
    }
};

Menjalankan Migration: Setelah mendefinisikan struktur tabel, jalankan perintah berikut untuk menjalankan migration dan membuat tabel artikels di database:
```
php artisan migrate
```

4. Membuat Controller untuk Mengelola Permintaan API

Setelah model dan migration dibuat, kita perlu membuat controller untuk mengelola permintaan API. Controller akan menerima permintaan dari client, berinteraksi dengan model untuk mengambil atau memanipulasi data, dan mengembalikan respon ke client.

Membuat Controller: Jalankan perintah berikut untuk membuat controller ArtikelController:
```
php artisan make:controller ArtikelController --api
```
Opsi --api akan membuat controller dengan method-method yang umum digunakan dalam API, seperti index, store, show, update, dan destroy.
Ini akan membuat file ArtikelController.php di direktori app/Http/Controllers.

Implementasi Method Controller: Buka file ArtikelController.php dan implementasikan method-method tersebut sesuai dengan logika bisnis Anda. Berikut adalah contoh implementasi:

<?php

namespace AppHttpControllers;

use AppModelsArtikel;
use IlluminateHttpRequest;
use IlluminateSupportFacadesValidator;

class ArtikelController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $artikels = Artikel::all();
        return response()->json([
            'success' => true,
            'message' => 'Daftar Artikel',
            'data' => $artikels
        ], 200);
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'judul' => 'required|string|max:255',
            'isi' => 'required|string',
            'penulis' => 'required|string|max:255',
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validasi Gagal',
                'errors' => $validator->errors()
            ], 422);
        }

        $artikel = Artikel::create($request->all());

        return response()->json([
            'success' => true,
            'message' => 'Artikel Berhasil Ditambahkan',
            'data' => $artikel
        ], 201);
    }

    /**
     * Display the specified resource.
     */
    public function show($id)
    {
        $artikel = Artikel::find($id);

        if (!$artikel) {
            return response()->json([
                'success' => false,
                'message' => 'Artikel Tidak Ditemukan'
            ], 404);
        }

        return response()->json([
            'success' => true,
            'message' => 'Detail Artikel',
            'data' => $artikel
        ], 200);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, $id)
    {
         $validator = Validator::make($request->all(), [
            'judul' => 'string|max:255',
            'isi' => 'string',
            'penulis' => 'string|max:255',
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validasi Gagal',
                'errors' => $validator->errors()
            ], 422);
        }

        $artikel = Artikel::find($id);

        if (!$artikel) {
            return response()->json([
                'success' => false,
                'message' => 'Artikel Tidak Ditemukan'
            ], 404);
        }

        $artikel->update($request->all());

        return response()->json([
            'success' => true,
            'message' => 'Artikel Berhasil Diperbarui',
            'data' => $artikel
        ], 200);
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy($id)
    {
        $artikel = Artikel::find($id);

        if (!$artikel) {
            return response()->json([
                'success' => false,
                'message' => 'Artikel Tidak Ditemukan'
            ], 404);
        }

        $artikel->delete();

        return response()->json([
            'success' => true,
            'message' => 'Artikel Berhasil Dihapus'
        ], 200);
    }
}

Penjelasan Kode:

index(): Mengembalikan daftar semua artikel dalam format JSON.
store(Request $request): Menyimpan artikel baru ke database. Method ini melakukan validasi data menggunakan Validator dan mengembalikan respon yang sesuai.
show($id): Mengembalikan detail artikel berdasarkan ID.
update(Request $request, $id): Memperbarui artikel berdasarkan ID. Method ini juga melakukan validasi data.
destroy($id): Menghapus artikel berdasarkan ID.

5. Mendefinisikan Rute API di `routes/api.php`

Setelah controller dibuat, kita perlu mendefinisikan rute API di file routes/api.php. File ini berisi daftar endpoint API dan menghubungkannya dengan method controller yang sesuai.

Mendefinisikan Rute: Buka file routes/api.php dan tambahkan kode berikut:
```
<?php

use IlluminateHttpRequest;
use IlluminateSupportFacadesRoute;
use AppHttpControllersArtikelController;

/*
|--------------------------------------------------------------------------
| API Routes
|--------------------------------------------------------------------------
|
| Here is where you can register API routes for your application. These
| routes are loaded by the RouteServiceProvider and all of them will
| be assigned to the "api" middleware group. Make something great!
|
*/

Route::middleware('auth:sanctum')->get('/user', function (Request $request) {
    return $request->user();
});

Route::resource('artikels', ArtikelController::class);
```
Kode Route::resource('artikels', ArtikelController::class); akan secara otomatis membuat rute-rute berikut:
- GET /api/artikels: Menampilkan daftar semua artikel (memanggil method index di ArtikelController).
- POST /api/artikels: Membuat artikel baru (memanggil method store di ArtikelController).
- GET /api/artikels/{artikel}: Menampilkan detail artikel dengan ID tertentu (memanggil method show di ArtikelController).
- PUT /api/artikels/{artikel}: Memperbarui artikel dengan ID tertentu (memanggil method update di ArtikelController).
- DELETE /api/artikels/{artikel}: Menghapus artikel dengan ID tertentu (memanggil method destroy di ArtikelController).

6. Otentikasi API dengan Laravel Sanctum

Keamanan adalah hal yang sangat penting dalam membangun API. Laravel menyediakan beberapa cara untuk mengamankan API, salah satunya adalah dengan menggunakan Laravel Sanctum. Sanctum menyediakan sistem otentikasi sederhana berbasis token yang cocok untuk API yang digunakan oleh SPA (Single Page Application) atau aplikasi mobile.

Instalasi Sanctum: Jalankan perintah berikut untuk menginstal Sanctum:
```
composer require laravel/sanctum
```
Publish Konfigurasi dan Migration: Jalankan perintah berikut untuk mem-publish file konfigurasi dan migration Sanctum:
```
php artisan vendor:publish --provider="LaravelSanctumSanctumServiceProvider"
php artisan migrate
```

Konfigurasi Model User: Buka file app/Models/User.php dan tambahkan trait HasApiTokens ke model User:

<?php

namespace AppModels;

// use IlluminateContractsAuthMustVerifyEmail;
use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateFoundationAuthUser as Authenticatable;
use IlluminateNotificationsNotifiable;
use LaravelSanctumHasApiTokens;

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

    // ...
}

Membuat Rute untuk Registrasi dan Login: Buat controller baru bernama AuthController dan tambahkan rute untuk registrasi dan login:

php artisan make:controller AuthController

Kemudian, tambahkan kode berikut ke routes/api.php:

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

Route::middleware('auth:sanctum')->group(function () {
    Route::get('/user', function (Request $request) {
        return $request->user();
    });
    Route::post('/logout', [AuthController::class, 'logout']);
    Route::resource('artikels', ArtikelController::class); // pindahkan route artikel kedalam group ini
});

Implementasi AuthController: Implementasikan method register, login, dan logout di AuthController:

<?php

namespace AppHttpControllers;

use AppModelsUser;
use IlluminateHttpRequest;
use IlluminateSupportFacadesAuth;
use IlluminateSupportFacadesHash;
use IlluminateSupportFacadesValidator;

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

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validasi Gagal',
                'errors' => $validator->errors()
            ], 422);
        }

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

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

        return response()->json([
            'success' => true,
            'message' => 'Registrasi Berhasil',
            'data' => [
                'user' => $user,
                'access_token' => $token,
                'token_type' => 'Bearer',
            ]
        ], 201);
    }

    public function login(Request $request)
    {
        if (!Auth::attempt($request->only('email', 'password'))) {
            return response()->json([
                'success' => false,
                'message' => 'Email atau Password Salah',
            ], 401);
        }

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

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

        return response()->json([
            'success' => true,
            'message' => 'Login Berhasil',
            'data' => [
                'user' => $user,
                'access_token' => $token,
                'token_type' => 'Bearer',
            ]
        ], 200);
    }

    public function logout(Request $request)
    {
        $request->user()->currentAccessToken()->delete();

        return response()->json([
            'success' => true,
            'message' => 'Logout Berhasil'
        ], 200);
    }
}

Sekarang, semua rute di dalam Route::middleware('auth:sanctum')->group(function () { ... }); hanya dapat diakses oleh pengguna yang sudah terotentikasi dan memiliki token Sanctum yang valid.

7. Menggunakan Resource Controllers untuk Struktur API yang Lebih Terorganisir

Laravel Resource Controllers adalah cara yang bagus untuk mengelola sumber daya (resources) API dengan cara yang terstruktur dan konsisten. Kita sudah menggunakan resource controller pada langkah sebelumnya dengan perintah php artisan make:controller ArtikelController --api.

Resource Controllers menyediakan method-method standar untuk melakukan operasi CRUD:

index(): Menampilkan daftar semua sumber daya.
store(Request $request): Membuat sumber daya baru.
show($id): Menampilkan detail sumber daya dengan ID tertentu.
update(Request $request, $id): Memperbarui sumber daya dengan ID tertentu.
destroy($id): Menghapus sumber daya dengan ID tertentu.

Dengan menggunakan Resource Controllers, kita dapat memastikan bahwa API kita memiliki struktur yang konsisten dan mudah dipahami.

8. Validasi Data dengan Request Validation

Validasi data adalah bagian penting dari membangun API yang aman dan handal. Laravel menyediakan fitur Request Validation yang memudahkan kita untuk memvalidasi data yang dikirim oleh client.

Membuat Form Request: Jalankan perintah berikut untuk membuat Form Request ArtikelRequest:
```
php artisan make:request ArtikelRequest
```
Ini akan membuat file ArtikelRequest.php di direktori app/Http/Requests.

Mendefinisikan Aturan Validasi: Buka file ArtikelRequest.php dan definisikan aturan validasi di method rules():

<?php

namespace AppHttpRequests;

use IlluminateFoundationHttpFormRequest;

class ArtikelRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     */
    public function authorize(): bool
    {
        return true; // Set to false if you need to authorize the request
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array<string, IlluminateContractsValidationValidationRule|array|string>
     */
    public function rules(): array
    {
        return [
            'judul' => 'required|string|max:255',
            'isi' => 'required|string',
            'penulis' => 'required|string|max:255',
        ];
    }
}

Menggunakan Form Request di Controller: Gunakan Form Request di method store dan update di ArtikelController:

public function store(ArtikelRequest $request)
{
    $artikel = Artikel::create($request->all());

    return response()->json([
        'success' => true,
        'message' => 'Artikel Berhasil Ditambahkan',
        'data' => $artikel
    ], 201);
}

public function update(ArtikelRequest $request, $id)
{
    $artikel = Artikel::find($id);

    if (!$artikel) {
        return response()->json([
            'success' => false,
            'message' => 'Artikel Tidak Ditemukan'
        ], 404);
    }

    $artikel->update($request->all());

    return response()->json([
        'success' => true,
        'message' => 'Artikel Berhasil Diperbarui',
        'data' => $artikel
    ], 200);
}

Dengan menggunakan Request Validation, kita dapat memastikan bahwa data yang diterima oleh API selalu valid dan sesuai dengan aturan yang kita definisikan.

9. Menguji API dengan Postman atau Thunder Client

Setelah API selesai dibangun, penting untuk menguji API tersebut untuk memastikan bahwa semuanya berjalan dengan baik. Anda dapat menggunakan aplikasi seperti Postman atau Thunder Client untuk mengirim permintaan ke API dan memeriksa respon yang dikembalikan.

Postman: Postman adalah aplikasi yang populer untuk menguji API. Anda dapat membuat koleksi request dan menyimpan konfigurasi API Anda.
Thunder Client: Thunder Client adalah ekstensi Visual Studio Code yang memungkinkan Anda untuk menguji API langsung dari dalam editor Anda.

Gunakan aplikasi-aplikasi ini untuk menguji semua endpoint API Anda, termasuk endpoint untuk membuat, membaca, memperbarui, dan menghapus data. Pastikan untuk menguji juga endpoint yang memerlukan otentikasi.

10. Dokumentasi API dengan OpenAPI (Swagger)

Dokumentasi API sangat penting untuk memudahkan developer lain untuk menggunakan API Anda. OpenAPI (sebelumnya dikenal sebagai Swagger) adalah standar industri untuk mendefinisikan dan mendokumentasikan API RESTful.

Instalasi Library Swagger: Anda dapat menggunakan library seperti darkaonline/l5-swagger untuk menghasilkan dokumentasi OpenAPI secara otomatis dari kode Laravel Anda. Instal library ini dengan Composer:
```
composer require darkaonline/l5-swagger
```

Konfigurasi Swagger: Publish file konfigurasi Swagger:

php artisan vendor:publish --provider "L5SwaggerL5SwaggerServiceProvider"

Generate Dokumentasi: Tambahkan anotasi Swagger ke controller dan model Anda untuk mendeskripsikan endpoint API dan struktur data. Kemudian, jalankan perintah berikut untuk menghasilkan dokumentasi OpenAPI:
```
php artisan l5-swagger:generate
```

Dokumentasi OpenAPI akan disimpan di direktori public/api/documentation dan dapat diakses melalui URL http://localhost:8000/api/documentation (sesuaikan dengan port yang Anda gunakan).

11. Logging dan Monitoring API

Logging dan monitoring sangat penting untuk memantau kinerja API dan mendeteksi masalah yang mungkin terjadi. Laravel menyediakan fitur logging yang memungkinkan kita untuk mencatat informasi tentang request, error, dan peristiwa-peristiwa lainnya.

Konfigurasi Logging: Laravel secara default menggunakan Monolog untuk logging. Anda dapat mengkonfigurasi logging di file config/logging.php.

Menggunakan Logging: Gunakan class Log untuk mencatat informasi:

use IlluminateSupportFacadesLog;

public function store(Request $request)
{
    try {
        $artikel = Artikel::create($request->all());

        Log::info('Artikel baru berhasil dibuat: ' . $artikel->id);

        return response()->json([
            'success' => true,
            'message' => 'Artikel Berhasil Ditambahkan',
            'data' => $artikel
        ], 201);
    } catch (Exception $e) {
        Log::error('Gagal membuat artikel: ' . $e->getMessage());

        return response()->json([
            'success' => false,
            'message' => 'Gagal Membuat Artikel',
            'error' => $e->getMessage()
        ], 500);
    }
}

Selain logging, Anda juga dapat menggunakan layanan monitoring seperti Sentry atau Bugsnag untuk memantau error dan kinerja API secara real-time.

12. Tips Tambahan untuk Membangun Laravel API yang Lebih Baik

Berikut adalah beberapa tips tambahan untuk membangun Laravel API yang lebih baik:

Gunakan Caching: Caching dapat meningkatkan kinerja API secara signifikan dengan menyimpan data yang sering diakses di cache. Laravel menyediakan fitur caching yang mudah digunakan.
Gunakan Queues: Queues memungkinkan kita untuk menunda tugas-tugas yang memakan waktu, seperti pengiriman email atau pemrosesan data yang kompleks.
Gunakan Pagination: Pagination sangat penting untuk API yang mengembalikan daftar data yang besar. Laravel menyediakan fitur pagination yang mudah digunakan.
Gunakan API Versioning: API versioning memungkinkan kita untuk membuat perubahan pada API tanpa merusak aplikasi yang sudah ada.
Tulis Unit Tests: Unit tests membantu kita untuk memastikan bahwa kode API kita berfungsi dengan benar dan tidak ada bug.

Kesimpulan

Membangun Laravel API yang modern dan efisien membutuhkan pemahaman tentang berbagai konsep dan teknologi. Dalam artikel ini, kita telah membahas langkah-langkah penting dalam membangun Laravel API, mulai dari instalasi Laravel, konfigurasi database, pembuatan model dan migration, implementasi controller, otentikasi API, validasi data, hingga dokumentasi API dan logging. Dengan mengikuti panduan ini dan menerapkan tips-tips tambahan yang diberikan, Anda dapat membangun Laravel API yang handal, aman, dan mudah digunakan. Selamat mencoba!

Tags: API Design API Development Backend Development Laravel Laravel API Modern Backend PHP PHP Framework RESTful API Web Development

Laravel API: Membangun Backend Modern dengan Laravel

Membuat API Authentication dengan Laravel Sanctum: Panduan Lengkap

Cara Meningkatkan Keamanan Website Laravel dari Serangan Hacker

Top 5 Package Laravel yang Mempermudah Pengembangan Website Anda

Cara Menggunakan Laravel Eloquent untuk Query Database: Panduan Lengkap

Finnian

Related Posts

Membuat API Authentication dengan Laravel Sanctum: Panduan Lengkap

Cara Meningkatkan Keamanan Website Laravel dari Serangan Hacker

Top 5 Package Laravel yang Mempermudah Pengembangan Website Anda

Laravel Livewire: Membuat Aplikasi Web Interaktif Tanpa JavaScript Kompleks

Leave a Reply Cancel reply

Recommended

Lowongan Kerja Web Development Fresh Graduate: Tips Mendapatkan Pekerjaan Impian

Tutorial Laravel Dasar untuk Pemula Bahasa Indonesia: Mulai Membangun Aplikasi Web

Desain Website Modern dan Menarik: Tingkatkan Konversi dengan Visual yang Memukau

Generator AI untuk Membuat Logo Website dengan Mudah

Tools AI Gratis untuk Meningkatkan Produktivitas Konten Marketing Anda

Cara Membuat Artikel SEO-Friendly dengan Bantuan AI

Aplikasi AI Terbaik untuk Mengedit Foto Produk Online: Tingkatkan Penjualanmu Sekarang!

m.techreview.click

Recent Posts

Categories

Resource

Laravel API: Membangun Backend Modern dengan Laravel

1. Mengapa Memilih Laravel untuk Membangun API?

2. Persiapan Awal: Instalasi Laravel dan Konfigurasi Database

Related Post

3. Membuat Model dan Migration untuk Sumber Daya API

4. Membuat Controller untuk Mengelola Permintaan API

5. Mendefinisikan Rute API di routes/api.php

6. Otentikasi API dengan Laravel Sanctum

7. Menggunakan Resource Controllers untuk Struktur API yang Lebih Terorganisir

8. Validasi Data dengan Request Validation

9. Menguji API dengan Postman atau Thunder Client

10. Dokumentasi API dengan OpenAPI (Swagger)

11. Logging dan Monitoring API

12. Tips Tambahan untuk Membangun Laravel API yang Lebih Baik

Kesimpulan

Related Posts

Leave a Reply Cancel reply

Recommended

m.techreview.click

Recent Posts

Categories

Resource

5. Mendefinisikan Rute API di `routes/api.php`