Fastify Restful API — Bagian 7: Integrasi Database dengan Knex (Migrasi dan Seed)

Di artikel sebelumnya, “Fastify Restful API — Bagian 6: Langkah Mudah Bikin Dokumentasi API dengan Swagger UI” kita udah bahas gimana cara bikin dokumentasi API yang keren dan gampang pakai Swagger UI. Dokumentasi yang bagus itu penting banget biar API kita bisa dipahami dan dipakai sama developer lain. Dengan Swagger UI, kita bisa bikin dokumentasi yang interaktif dan bisa diakses langsung dari endpoint API kita.

Nah, sekarang kita lanjut ke topik yang nggak kalah penting, yaitu integrasi database pakai Objection.js dan Knex. Objection.js itu ORM (Object-Relational Mapper) yang dibangun di atas Knex.js, query builder SQL untuk Node.js. Di artikel ini, kita bakal bahas gimana cara melakukan migrasi dan seed database. Ini langkah penting buat ngatur skema dan data awal aplikasi kita.

Keunggulan Knex.js dalam Pengelolaan Database

Knex.js itu query builder SQL buat Node.js yang mendukung berbagai database seperti PostgreSQL, MySQL, dan SQLite. Query builder ini alat yang bantu kita nulis query SQL dengan cara yang lebih mudah dan terstruktur pakai JavaScript. Knex.js menyediakan antarmuka yang konsisten buat berbagai jenis database, jadi kita bisa nulis query yang sama tanpa perlu pusing mikirin perbedaan sintaks SQL di berbagai database. Jadi, hidup kita sebagai developer jadi lebih simpel dan efisien!

Persiapan

Di bagian ini, kita akan mempersiapkan beberapa hal sebelum mulai coding. Untuk menyimpan data, kita akan menggunakan PostgreSQL sebagai database di panduan ini.

Setup dan Buat Database dengan PostgreSQL

Sebelum kita melanjutkan ke tahap pengembangan, pastikan PostgreSQL sudah terinstal dan terkonfigurasi dengan baik di perangkat kamu, baik di Windows maupun di Mac. Kamu bisa membuat database menggunakan command line PostgreSQL atau alat GUI seperti pgAdmin. Di sini, kita akan menggunakan terminal untuk membuat database. Berikut langkah-langkahnya:

Cek Versi PostgreSQL Untuk memastikan PostgreSQL sudah terinstal dengan benar, buka terminal dan jalankan perintah berikut:

psql --version

Ini akan menampilkan versi PostgreSQL yang terinstal. Jika belum terinstal, pastikan untuk mengunduh dan menginstalnya dari situs resmi PostgreSQL.

Memulai PostgreSQL dan Membuat Database

Setelah memastikan PostgreSQL terinstal, kamu bisa memulai server PostgreSQL dan membuat database yang dibutuhkan. Di sini, kita akan membuat database bernama learn_fastify. Jalankan perintah ini di terminal:

psql -U postgres

Setelah menjalankan perintah di atas, PostgreSQL akan meminta kamu memasukkan password untuk pengguna root. Masukkan password yang sudah kamu set sebelumnya.

Buat Database learn_fastify

Setelah berhasil masuk ke PostgreSQL, sekarang saatnya membuat database dengan nama learn_fastify. Jalankan perintah berikut:

CREATE DATABASE learn_fastify;

Jika perintah berhasil, database learn_fastify akan dibuat, dan kamu siap untuk melanjutkan ke langkah berikutnya dalam pengembangan aplikasi.

Dengan langkah-langkah ini, kita sudah siap menghubungkan aplikasi kita dengan PostgreSQL dan mulai bekerja dengan database!

Mempersiapkan File Config untuk Database PostgreSQL

Untuk mengonfigurasi koneksi ke database PostgreSQL di proyek kita, kita perlu menambahkan beberapa variabel di file .env.development dan memperbarui skema konfigurasi di config.ts.

Langkah 1: Menambahkan Variabel di File .env.development

Buka file .env.development dan tambahkan variabel berikut untuk mengatur koneksi PostgreSQL:

....
KNEX_CLIENT=postgres
KNEX_CONNECTION_HOST=localhost
KNEX_CONNECTION_PORT=5432
KNEX_CONNECTION_DATABASE=learn_fastify
KNEX_CONNECTION_USER=postgres
KNEX_CONNECTION_PASSWORD=123456
KNEX_POOL_MIN=2
KNEX_POOL_MAX=10
KNEX_MIGRATIONS_TABLENAME=knex_migrations

• KNEX_CLIENT: Menentukan jenis database yang digunakan, di sini adalah "postgres".
• KNEX_CONNECTION_HOST: Host database yang akan kita gunakan (localhost).
• KNEX_CONNECTION_PORT: Port database yang akan kita gunakan (5432).
• KNEX_CONNECTION_DATABASE: Nama database yang akan kita gunakan (learn_fastify).
• KNEX_CONNECTION_USER: Nama pengguna PostgreSQL yang akan mengakses database.
• KNEX_CONNECTION_PASSWORD: Kata sandi pengguna PostgreSQL.
• KNEX_POOL_MIN dan KNEX_POOL_MAX: Menentukan jumlah minimum dan maksimum koneksi dalam pool.
• KNEX_MIGRATIONS_TABLENAME: Nama tabel untuk menyimpan riwayat migrasi.

Langkah 2: Memperbarui Skema Konfigurasi di /src/utils/config.ts

Selanjutnya, buka file /src/utils/config.ts dan tambahkan variabel-variabel tersebut di dalam objek schema untuk memastikan semua konfigurasi database dikenali oleh aplikasi:

const schema = {
  ...
  required: [
    ...
    "KNEX_CLIENT",
    "KNEX_CONNECTION_HOST",
    "KNEX_CONNECTION_PORT"  
  ],
  properties: {
    ...
    KNEX_CLIENT: {
      type: "string",
      default: "postgres",
    },
    KNEX_CONNECTION_HOST: {
      type: "string",
    },    
    KNEX_CONNECTION_PORT: {
      type: "number",
    },
    KNEX_CONNECTION_DATABASE: {
      type: "string",
    },
    KNEX_CONNECTION_USER: {
      type: "string",
    },
    KNEX_CONNECTION_PASSWORD: {
      type: "string",
    },
    KNEX_POOL_MIN: {
      type: "number",
    },
    KNEX_POOL_MAX: {
      type: "number",
    },
    KNEX_MIGRATIONS_TABLENAME: {
      type: "string",
    },
  },
} as const;

Dengan menambahkan konfigurasi ini di config.ts, kita memastikan aplikasi dapat membaca pengaturan koneksi database dari file .env.development dan menyesuaikan koneksi database saat dijalankan.

Install dan konfigurasi knex

Nah, supaya bisa berinteraksi dengan PostgreSQL dari aplikasi kita, kita butuh dua module penting: Knex dan PostgreSQL. Knex ini akan membantu kita bikin query ke database dengan lebih mudah, tanpa harus nulis raw SQL. Sedangkan, module PostgreSQL adalah driver yang digunakan untuk menghubungkan Node.js dengan PostgreSQL.

Yuk, install module-module tersebut dengan perintah ini di terminal:

npm install knex pg

Kita akan menambahkan beberapa script baru di bagian scripts dalam file package.json supaya memudahkan dalam menjalankan berbagai perintah migrasi menggunakan Knex. Dengan script ini, kita bisa melakukan hal-hal seperti mengecek versi migrasi saat ini, membuat migrasi baru, menjalankan migrasi terbaru, dan melakukan rollback migrasi.

Tambahkan script berikut ke dalam file package.json:

{
  "scripts": {
    ...
    "knex:init": "knex init -x ts",
    "knex:run": "knex --knexfile src/configs/knexfile.ts",
  }
}

Berikut penjelasan untuk setiap script:

• **knex:init**: Inisialisasi file konfigurasi Knex (knexfile.ts) dengan ekstensi TypeScript (-x ts). Ini akan menghasilkan file knexfile.ts di folder src.
• **knex:run**: Menjalankan Knex dengan menggunakan file konfigurasi Knex yang ada di src/configs/knexfile.ts.

Seluruh script yang ada sekarang sudah mendukung proyek berbasis TypeScript, sehingga semua perintah migrasi akan berinteraksi dengan file knexfile.ts di dalam folder src.Dengan ini, kita bisa lebih mudah mengelola migrasi database di proyek kita!

Setelah script sudah ada, jalankan perintah berikut di terminal:

npm run knex:init

Perintah ini akan membuat file knexfile.ts di root folder proyek. File ini adalah konfigurasi yang digunakan Knex untuk menghubungkan ke database.

Selanjutnya, kita akan memindahkan file knexfile.ts ke dalam folder src. Jalankan perintah berikut di terminal:

mv knexfile.ts src/configs/

Ini akan memindahkan file knexfile.ts ke folder src, sehingga struktur foldernya akan menjadi:

/src
  └── configs
      └── knexfile.ts

Setelah file knexfile.ts berada di folder src, kita perlu melakukan beberapa perubahan konfigurasi di dalam file tersebut, terutama untuk pengaturan koneksi ke MySQL. Berikut adalah contoh konfigurasi yang bisa kamu gunakan:

import type { Knex } from "knex";

import type { Knex } from "knex";
import configApp from "../utils/config";
// Update with your config settings.

const config: Knex.Config = {
  client: configApp.KNEX_CLIENT,
  connection: {
    host: configApp.KNEX_CONNECTION_HOST,
    port: configApp.KNEX_CONNECTION_PORT,
    database: configApp.KNEX_CONNECTION_DATABASE,    
    user: configApp.KNEX_CONNECTION_USER,
    password: configApp.KNEX_CONNECTION_PASSWORD,
  },
  pool: {
    min: configApp.KNEX_POOL_MIN,
    max: configApp.KNEX_POOL_MAX,
  },
  migrations: {
    tableName: configApp.KNEX_MIGRATIONS_TABLENAME,
    directory: "./../migrations",
  },
  seeds: {
    directory: "./../seeds",
  },
};

module.exports = config;

Penjelasan konfigurasi:

• client: Menentukan jenis database yang digunakan. Kita pakai mysql.
• connection: Berisi detail koneksi ke database, termasuk host, port, username, password, dan nama database.
• migrations.directory: Menentukan lokasi folder untuk menyimpan file migrasi.
• seeds.directory: Menentukan lokasi folder untuk menyimpan file seed (data awal).

Migration Database

Kita akan menambahkan beberapa script baru di bagian scripts dalam file package.json supaya memudahkan dalam menjalankan berbagai perintah migrasi menggunakan Knex. Dengan script ini, kita bisa melakukan hal-hal seperti mengecek versi migrasi saat ini, membuat migrasi baru, menjalankan migrasi terbaru, dan melakukan rollback migrasi.

{
  "scripts": {
    ...
    "knex:init": "knex init -x ts",
    "knex:run": "knex --knexfile src/configs/knexfile.ts",
    "migrate:currentVersion": "npm run knex:run -- migrate:currentVersion",
    "migrate:make":"npm run knex:run -- migrate:make --",
    "migrate:list":"npm run knex:run -- migrate:list",
    "migrate:latest":"npm run knex:run -- migrate:latest --debug",
    "migrate:rollback": "npm run knex:run -- migrate:rollback --all --debug",
    "seed:make": "npm run knex:run -- seed:make --",
    "seed:run": "npm run knex:run -- seed:run --debug",
    "migrate:development:make": "cross-env NODE_ENV=development npm run migrate:make",
    "migrate:development:list": "cross-env NODE_ENV=development npm run migrate:list",
    "migrate:development:latest": "cross-env NODE_ENV=development npm run migrate:latest",
    "migrate:development:rollback": "cross-env NODE_ENV=development npm run migrate:rollback",
    "seed:development:make": "cross-env NODE_ENV=development npm run seed:make",
    "seed:development:run": "cross-env NODE_ENV=development npm run seed:run",
    "migrate:production:make": "cross-env NODE_ENV=productionnpm run migrate:make",
    "migrate:production:list": "cross-env NODE_ENV=productionnpm run migrate:list",
    "migrate:production:latest": "cross-env NODE_ENV=productionnpm run migrate:latest",
    "migrate:production:rollback": "cross-env NODE_ENV=productionnpm run migrate:rollback",
    "seed:production:make": "cross-env NODE_ENV=productionnpm run seed:make",
    "seed:production:run": "cross-env NODE_ENV=productionnpm run seed:run" 
  }
}

• **cross-env NODE_ENV=development**: cross-env digunakan untuk mengatur NODE_ENV=development pada semua sistem operasi. Dengan menambahkan NODE_ENV=development, kita memastikan bahwa migrasi berjalan pada konfigurasi untuk lingkungan development.
• **npm run knex:run --**: Ini memanggil script knex:run (yang harus sudah didefinisikan sebelumnya di package.json) dan menambahkan perintah tambahan setelah -- untuk menjalankan fungsi migrasi sesuai kebutuhan.

Berikut adalah penjelasan dari setiap script di atas yang membantu mengelola migrasi dan seeding database untuk berbagai lingkungan (development dan production).

Script Dasar untuk Migrasi dan Seed

**migrate:make**:

• Membuat file migrasi baru di direktori migrasi.
• Sintaks: npm run migrate:make <nama_migrasi>.

**migrate:list**:

• Menampilkan daftar migrasi yang sudah dijalankan dan belum dijalankan.

**migrate:latest**:

• Menjalankan semua migrasi yang belum dijalankan (meng-update database ke versi terbaru).
• Opsi --debug digunakan untuk menampilkan informasi tambahan untuk debugging.

**migrate:rollback**:

• Membatalkan (rollback) migrasi terakhir yang diterapkan, dengan opsi --all untuk membatalkan semua migrasi sekaligus, serta --debug untuk debugging tambahan.

**seed:make**:

• Membuat file seed baru di direktori seeding.
• Sintaks: npm run seed:make <nama_seed>.

**seed:run**:

• Menjalankan semua seed file yang ada untuk mengisi data awal di database.
• Opsi --debug digunakan untuk debugging.

Script untuk Lingkungan development / production / staging

migrate:development:make, migrate:development:list, migrate:development:latest, migrate:development:rollback:

• Semua script ini menjalankan perintah migrasi pada lingkungan development. cross-env NODE_ENV=development mengatur NODE_ENV ke development, yang memastikan pengaturan database dan konfigurasi khusus development yang diterapkan.

seed:development:make, seed:development:run:

• Script ini membuat dan menjalankan seed file di lingkungan development menggunakan konfigurasi khusus development.

Menggunakan Knex Migrations untuk Membuat Tabel Database

Dalam panduan ini, kita akan menggunakan Knex migrations untuk membuat tabel-tabel di database dan melacak perubahan dalam skema database kita. Migrations memudahkan kita untuk mengubah tabel bahkan setelah semua tabel sudah dibuat. Ini jauh lebih praktis daripada menulis SQL mentah, karena Knex memberikan API yang lebih intuitif dan mendukung pengelolaan skema yang lebih baik.

Contoh Skema SQL

Misalnya, kita ingin membuat dua tabel: roles dan users. Dalam SQL biasa, skema tersebut mungkin akan terlihat seperti ini:

CREATE TABLE IF NOT EXISTS roles (
    id INT PRIMARY KEY AUTO_INCREMENT,
    role_name VARCHAR(45) NOT NULL
);

CREATE TABLE IF NOT EXISTS users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(45) NOT NULL,
    email VARCHAR(255) NOT NULL,
    role_id INT,
    FOREIGN KEY (role_id)
      REFERENCES roles (id)
      ON DELETE SET NULL
      ON UPDATE CASCADE
);

Tabel ini sangat sederhana, di mana users memiliki foreign key yang menghubungkan dengan tabel roles. Setiap pengguna memiliki satu peran, dan satu peran dapat dimiliki oleh banyak pengguna.

Membuat Migration untuk Tabel roles

Untuk menggunakan Knex migration, kita akan membuat file migration yang akan menjalankan kode untuk membuat tabel di database. Berikut langkah-langkahnya:

Buat migration untuk tabel roles dengan perintah berikut di folder proyek kamu:

npm run migrate:make roles

Ini akan membuat file migration di dalam folder migrations dengan nama yang mengandung timestamp. Timestamp ini penting untuk menentukan urutan eksekusi migration oleh Knex.

Buka file migration yang baru dibuat di folder migrations. Di dalam file tersebut, tambahkan kode berikut untuk mendefinisikan tabel roles:

import type { Knex } from "knex";

export async function up(knex: Knex): Promise<void> {
    return knex.schema.createTable("roles", table => {
        table.increments("id").primary();
        table.string("role_name", 45).notNullable();
    });
}

export async function down(knex: Knex): Promise<void> {
    return knex.schema.dropTable("roles");
}

• **up function**: Di sinilah tabel roles dibuat. Kolom id menggunakan metode increments() untuk auto-increment dan menandai sebagai primary key. Kolom role_name diatur dengan panjang maksimum 45 karakter dan ditambahkan constraint NOT NULL.
• **down function**: Digunakan untuk membatalkan migration jika diperlukan, di sini kita cukup menghapus tabel roles dengan dropTable().

Membuat Migration untuk Tabel users

Setelah tabel roles dibuat, kita akan membuat migration untuk tabel users:

Buat migration untuk tabel users dengan perintah:

npm run migrate:make users

Buka file migration yang dibuat untuk users, lalu tambahkan kode berikut:

• **role_id**: Kolom ini adalah foreign key yang menghubungkan tabel users dengan roles. Kita menggunakan unsigned() untuk memastikan tipe data integer-nya konsisten dengan kolom id di tabel roles.
• **foreign(): Menambahkan constraint foreign key. Di sini kita menentukan bahwa role_id di tabel users merujuk ke kolom id di tabel roles. Juga, kita menambahkan aturan ON DELETE SET NULL dan ON UPDATE CASCADE**. Artinya, jika sebuah role dihapus, maka role_id di users akan di-set NULL, dan jika id di roles berubah, maka referensi di users akan diperbarui secara otomatis.

Menggunakan Migration untuk Membuat Tabel

Setelah menulis file migration, kita bisa menjalankan perintah berikut untuk menjalankan migrasi dan membuat tabel di database:

npm run migrate:latest

untuk menjalankan migrasi pada production:

npm run migrate:latest --env production

Perintah ini akan menjalankan semua migration yang belum dijalankan, mulai dari migration dengan timestamp terlama, dalam hal ini roles, lalu diikuti dengan users.

Rollback (Membatalkan Migrasi)

Jika kamu ingin membatalkan migrasi, misalnya jika ada kesalahan, kamu bisa menjalankan perintah rollback:

npm run migrate:rollback

untuk menjalankan rollback pada production:

npm run migrate:rollback --env production

Ini akan menjalankan fungsi down dari file migration, menghapus tabel yang dibuat.

Menambahkan Timestamps pada Tabel Database

Timestamps adalah elemen penting yang sering digunakan di semua tabel database. Fungsinya untuk membantu melakukan logging dan monitoring perubahan data, seperti kapan data dibuat dan diubah. Dengan Knex, sangat mudah untuk menambahkan timestamps ini ke tabel yang sudah ada.

Langkah-langkah Menambahkan Timestamps

Untuk menambahkan timestamps ke tabel users, kita perlu membuat migration baru dan menggunakan metode timestamps() yang disediakan oleh Knex.

Buat migration baru dengan perintah berikut:

npm run migrate:make add_user_timestamp

Ini akan menghasilkan file migration baru di dalam folder migrations.

Buka file migration yang baru dibuat, kemudian tambahkan kode berikut:

import type { Knex } from "knex";

export async function up(knex: Knex): Promise<void> {
    return knex.schema.table("users", table => {
        table.timestamps(false, true);
    });
}

export async function down(knex: Knex): Promise<void> {
    return knex.schema.table("users", table => {
        table.dropTimestamps();
    });
}

Penjelasan Kode:

**table.timestamps(false, true)**:

• Argumen pertama (false): Mengatur tipe data kolom created_at dan updated_at. Jika kita set true, maka tipe datanya akan menjadi TIMESTAMP (di MySQL). Jika false, akan tetap sebagai DATETIME.
• Argumen kedua (true): Mengatur nilai default untuk created_at dan updated_at ke current_timestamp(). Artinya, setiap kali data ditambahkan ke tabel, kolom created_at dan updated_at otomatis diisi dengan waktu saat ini.
• **exports.down: Fungsi ini akan dijalankan jika kita melakukan rollback** pada migrasi. Di sini, kita menggunakan table.dropTimestamps() untuk menghapus kolom created_at dan updated_at.

Menambahkan timestamps ke tabel database sangat berguna untuk melacak kapan data dibuat dan diperbarui. Dengan Knex, kita bisa melakukannya dengan mudah menggunakan metode timestamps(). Metode ini menambahkan kolom created_at dan updated_at, dan secara otomatis mengisi nilainya menggunakan current_timestamp() setiap kali data diubah atau ditambahkan.

Seeding di Database

Seeding berarti mengisi tabel database dengan data awal atau default. Ini sangat berguna untuk memberikan nilai-nilai awal pada tabel atau untuk tujuan pengujian. Knex menyediakan cara yang mudah untuk melakukan seeding pada database. Dalam contoh ini, kita akan melakukan seeding pada tabel roles dengan beberapa nilai awal.

Biasanya, seeding digunakan untuk:

• Mengatur nilai yang sudah ditentukan sebelumnya (seperti peran pengguna).
• Pengujian dengan data dummy (kamu juga bisa menggunakan library seperti faker.js untuk menghasilkan data palsu).

Kita akan menambahkan beberapa script baru di bagian scripts dalam file package.json agar memudahkan proses pembuatan dan menjalankan seeder, tambahkan script berikut ke bagian scripts:

{
  "scripts": {
    ...
    "seed:make": "npm run knex:run -- seed:make --",
    "seed:run": "npm run knex:run -- seed:run --debug"
  }
}

**seed:make**: Menggunakan perintah seed:make untuk membuat file seed baru.

**seed:run: Menjalankan semua seed file yang sudah dibuat dengan mode debug** untuk menampilkan log proses seeding.

Menggunakan Knex Seed untuk mengisi data awal

Untuk memulai seeding, kita akan membuat file seeder dan mengisinya dengan data awal. Buat seed file dengan perintah berikut:

npm run seed:make seed_roles

Perintah ini akan membuat folder seeds di dalam proyek kamu, dan menghasilkan file seed_roles.js di dalamnya.

Buka file seed_roles.ts yang baru dibuat, lalu tambahkan kode berikut:

import { Knex } from "knex";

export async function seed(knex: Knex): Promise<void> {
  // Deletes ALL existing entries
  return knex("roles")
    .del()
    .then(function () {
      return knex("roles").insert([
        { role_name: "User" },
        { role_name: "Admin" },
        { role_name: "Staff" },
      ]);
    });
}

Penjelasan Kode:

• **knex("roles").del(): Sebelum kita menambahkan data baru, kita menggunakan metode del() untuk menghapus semua data yang ada di tabel roles**. Ini opsional, tapi berguna jika kamu ingin memulai dengan data yang bersih setiap kali menjalankan seed.
• **knex("roles").insert(): Kita menggunakan metode insert() untuk melakukan bulk insert, di mana kita menambahkan beberapa baris sekaligus ke tabel roles. Dalam contoh ini, kita memasukkan tiga peran: User, Admin, dan Staff**. Metode ini menerima array objek yang akan diinsert sebagai baris dalam tabel.

Menjalankan Seed

Setelah menulis kode seeding, jalankan perintah berikut untuk memasukkan data awal ke dalam tabel roles:

npm run seed:development:run

untuk menjalankan seed pada production:

seed:production:run

Perintah ini akan menjalankan file seeder yang sudah kamu buat dan menambahkan data ke tabel roles.

Menggunakan Seeder dalam Proyek

Seeding sangat berguna ketika kamu ingin mengatur data awal yang penting seperti peran pengguna, kategori produk, atau data awal lainnya. Kamu juga bisa menggunakannya untuk menambahkan data dummy saat melakukan pengujian.

Sebagai tambahan, kamu juga bisa menggunakan library seperti faker.js untuk menghasilkan data palsu dalam jumlah besar jika diperlukan untuk pengujian lebih mendalam.

Terima kasih

Terima kasih sudah mengikuti tutorial ini! 🎉 Sekarang kamu sudah siap untuk mengelola database dan mengisi tabel dengan data awal menggunakan Knex. Kamu telah belajar:

1. Cara Mengatur Migrasi: Membuat dan mengelola tabel database dengan migrasi, serta menulis fungsi up dan down untuk mengubah skema database.
2. Menambahkan Timestamps: Menyertakan kolom waktu otomatis seperti created_at dan updated_at untuk memantau perubahan data.
3. Melakukan Seeding: Mengisi tabel dengan data awal untuk mempersiapkan aplikasi atau untuk keperluan pengujian.

Dengan semua ini, kamu sudah punya dasar yang solid untuk melanjutkan pengembangan aplikasi. Jangan ragu untuk bermain-main dan mengembangkan fitur lebih lanjut!

Mau lihat contoh kode dari tutorial ini? Kamu bisa cek repository GitHub kami di sini. Semua file dan konfigurasi yang dibahas ada di situ, jadi kamu bisa langsung mulai.

Tutorial Selanjutnya

Jangan lewatkan tutorial berikutnya **Bagian 8: CRUD dengan Mudah Menggunakan Knex & Objection.js! Kita bakal bahas CRUD (Create, Read, Update, Delete)** dengan Knex dan objection.js. Kamu akan belajar cara bikin operasi dasar untuk mengelola data di database, dan menerapkannya dalam aplikasi. Pasti seru, jadi stay tuned!

Kalau ada pertanyaan atau butuh bantuan, jangan sungkan untuk hubungi kami. Selamat coding dan semoga sukses dengan proyekmu! 🚀

Terima kasih sudah baca tutorial ini, semoga bermanfaat!