Wednesday, 26 November 2025

Tutorial MongoDB connect to express JS use Driver MongoDB v7.0.0

 

Dalam pengembangan aplikasi backend dengan Node.js dan Express, MongoDB merupakan salah satu pilihan database NoSQL yang sangat populer. Banyak developer memilih menggunakan Mongoose untuk mengelola database karena menyediakan schema, validasi, dan abstraction layer. Namun, sebagian lainnya lebih menyukai menggunakan MongoDB Native Driver karena sifatnya yang lebih ringan, fleksibel, dan memberikan kontrol penuh terhadap interaksi langsung dengan database. Artikel ini akan membahas cara membuat koneksi MongoDB pada aplikasi Express menggunakan driver resmi MongoDB, mulai dari instalasi hingga konfigurasi koneksi yang baik dan aman.

1. Mengapa Menggunakan MongoDB Native Driver?

Sebelum masuk ke langkah-langkah teknis, penting untuk memahami alasan memilih MongoDB Driver dibanding Mongoose:

    a. Lebih ringan dan tanpa lapisan abstraksi tambahan

Driver ini berkomunikasi langsung dengan database tanpa schema enforcement. Cocok untuk proyek yang membutuhkan fleksibilitas atau performa tinggi.

    b. Kontrol penuh terhadap query dan operasi database 

Karena tidak ada ODM yang membungkus query, developer lebih bebas melakukan operasi kompleks.

    c. Lebih cocok untuk arsitektur mikroservis 

Banyak mikroservis modern menggunakan driver native agar footprint aplikasi lebih kecil.

    4. Mendukung penuh fitur terbaru MongoDB 

Kadang fitur baru MongoDB tersedia lebih awal pada driver dibanding di ODM seperti Mongoose.

2. Persiapan Proyek 

Pastikan Node.js dan npm sudah terinstal. Mulailah dengan membuat direktori baru:


mkdir express-mongodb-driver
cd express-mongodb-driver

Inisialisasi proyek:


npm init -y

Instal Express dan MongoDB driver:


npm install express mongodb

Jika ingin mempermudah pengembangan, install nodemon:


npm install --save-dev nodemon

3. Struktur Proyek


express-mongodb-driver/
│
├── server.js
└── config/
    └── database.js

File database.js akan menyimpan konfigurasi koneksi database. 

4. Membuat Koneksi MongoDB

Buat file config/database.js berisi:  


const { MongoClient } = require('mongodb');

const uri = 'mongodb://localhost:27017';
const client = new MongoClient(uri);

let db;

const connectDB = async () => {
    try {
        await client.connect();
        console.log('Berhasil terhubung ke MongoDB');

        db = client.db('database_name'); // nama database
    } catch (error) {
        console.error('Gagal terhubung ke MongoDB:', error.message);
        process.exit(1);
    }
};

const getDB = () => {
    if (!db) {
        throw new Error('Database belum terkoneksi!');
    }
    return db;
};

module.exports = { connectDB, getDB };

Penjelasan:

  • MongoClient adalah class inti untuk membuat koneksi ke server MongoDB.
  • client.connect() digunakan untuk membuka koneksi.
  • db = client.db('nama_database') menyimpan reference database.
  • Fungsi getDB() berguna agar database bisa dipanggil dari file lain tanpa membuat koneksi baru.

5. Menghubungkan MongoDB pada Express

Buka file server.js dan isi seperti berikut:


const express = require('express');
const { connectDB, getDB } = require('./config/database');

const app = express();
app.use(express.json());

// Koneksi ke database
connectDB();

app.get('/', (req, res) => {
    res.send('Aplikasi Express dengan MongoDB Native Driver');
});

// Contoh route yang mengambil data dari database
app.get('/user', async (req, res) => {
    try {
        const db = getDB();
        const users = await db.collection('users').find().toArray();
        res.json(users);
    } catch (error) {
        res.status(500).json({ message: error.message });
    }
});

const PORT = 3000;
app.listen(PORT, () => console.log(`Server berjalan pada port ${PORT}`));

Beberapa hal penting:

  • Kita memanggil connectDB() saat aplikasi dijalankan.
  • Untuk mengakses MongoDB di route Express, kita memanggil getDB() untuk mengambil instance database yang sudah terkoneksi.
  • Contoh route /users menunjukkan cara mengambil data dari koleksi menggunakan driver native.

6. Menjalankan Aplikasi

Jalankan server dengan:  


node server.js

Atau menggunakan nodemon:


npx nodemon server.js

Jika berhasil, Anda akan melihat:

$ npx nodemon server.js
[nodemon] 3.1.11
[nodemon] to restart at any time, enter `rs`
[nodemon] watching path(s): *.*
[nodemon] watching extensions: js,mjs,cjs,json
[nodemon] starting `node server.js`
Server berjalan pada port 3000
Berhasil terhubung ke MongoDB

Meskipun databasenya belum dibuat, mongodb akan membuat otomatis sesuai dengan nama database pada konfigurasi koneksi.

Jika kalian akses browset localhost:3000/user, akan kosong karna memamng datanya tidak ada, untuk membuktikannya silahkan buatk route baru misal user-add:


app.get('/user-add', async(req, res) => {
    try {
        const db = getDB();
        const users = await db.collection('users').insertOne({name:'Naruto', email:'naruto@konoha.com'});
        res.json(users);
    } catch (error) {
        res.status(500).json({ message: error.message });
    }
});

akses browser localhost:3000/user-add, setelah itu buka lagi localhost:3000/user, maka datanya akan ada sesuai yang di tambahkan sebelumnya.

7. Kesimpulan

Menggunakan MongoDB Native Driver pada aplikasi Express memberikan fleksibilitas maksimum dan performa lebih ringan dibanding menggunakan ODM seperti Mongoose. Walaupun Anda tidak mendapatkan fitur seperti schema, model, atau validasi otomatis, Anda memperoleh kontrol penuh atas operasi database dan dapat memanfaatkan fitur terbaru MongoDB tanpa menunggu update library lain.

Pendekatan ini cocok untuk aplikasi kecil, backend dengan performa tinggi, atau mikroservis yang membutuhkan jejak memori minimal. Dengan struktur yang modular, seperti memisahkan koneksi database ke dalam file khusus, aplikasi menjadi lebih rapi dan mudah diperluas.

Untuk melihat artikel yang lain bisa klik DisiniUntuk versi yang menggunakan Mongoose bisa cek Disini

Tutorial MongoDB connect to express JS use Mongoose 9.0.0

 

Dalam pengembangan aplikasi berbasis Node.js, penggunaan MongoDB sebagai database NoSQL sangat populer karena fleksibel, cepat, dan mudah diintegrasikan dengan berbagai framework JavaScript. Salah satu pendekatan paling umum untuk mengelola koneksi dan operasi database MongoDB dalam aplikasi Express adalah melalui Mongoose, sebuah Object Data Modeling (ODM) yang menyediakan struktur lebih terorganisasi untuk bekerja dengan MongoDB. Artikel ini akan membahas langkah-langkah membuat koneksi database MongoDB pada Express menggunakan Mongoose, mulai dari instalasi hingga konfigurasi koneksi dan penanganan error.

Ada 2 cara dalam membuat koneksi dari express ke mongodb, yaitu dengan cara minginstal driver mongoose, atau install driver mongodb. Pada artikel ini kita akan membahas koneksi dengan menggunakan driver mongoose.

1. Mengapa Menggunakan Mongoose? 

Mongoose menawarkan beberapa kelebihan penting, antara lain:

  • Schema-based Modeling : Anda bisa menentukan struktur data berupa schema, sehingga data lebih terorganisasi.
  • Validasi Otomatis : Mongoose menyediakan validator untuk memastikan data sesuai sebelum dimasukkan ke database.
  • Middleware / Hooks : Sangat berguna untuk menjalankan operasi sebelum atau sesudah aksi tertentu seperti save, update, dsb.
  • Query Builder yang Mudah Digunakan : Mongoose menyediakan API yang mudah dibaca dan digunakan.

Dengan fitur-fitur tersebut, Mongoose menjadi pilihan utama bagi developer Node.js yang ingin mengelola MongoDB dengan lebih rapi dan terstruktur. 

2. Persiapan Proyek

Pertama kali pastikan kalian sudah menginstall MongoDB Community Server jika belum bisa cek Disini, selanjutnya pastikan Node.js dan npm sudah terinstal. Buat direktori baru untuk proyek:


mkdir express-mongoose
cd express-mongoose

Inisialisasi proyek:


npm init -y

Kemudian instal Express dan Mongoose:


npm install express mongoose

Untuk kebutuhan pengembangan, Anda juga dapat menginstal nodemon:


npm install --save-dev nodemon

agar server pada express nanti otomatis reload tanpa harus jalankan ulang server

3. Struktur Proyek

Gunakan struktur sederhana seperti berikut:


express-mongoose-app/
│
├── server.js
└── config/
    └── database.js

Folder config digunakan untuk menyimpan konfigurasi koneksi database agar lebih rapi.

4. Membuat File Koneksi MongoDB

Buat file config/database.js dan isi dengan kode berikut:


const mongoose = require('mongoose');

const connectDB = async()=>{
    try {
      //  digunakan untuk memaksa Mongoose agar hanya mempertimbangkan field yang ada dalam skema saat melakukan query ke basis data
      mongoose.set('strictQuery', true);

      //koneksi ke mongodb
      await mongoose.connect('mongodb://localhost:27017/database_name');
      console.log('Berhasil terhubung ke MongoDB');
    } catch (error) {
        console.error('Gagal terhubung ke MongoDB:', error.message);
    }
};

module.exports = connectDB;

Jika Anda menggunakan MongoDB Atlas, cukup ganti URL koneksi menjadi connection string dari Atlas.

5. Menghubungkan Database pada Express

Sekarang buka file server.js dan isi sebagai berikut:


const express = require('express');
const connectDB = require('./config/database');

const app = express();

// Middleware untuk parsing JSON
app.use(express.json());

// Panggil koneksi database
connectDB();

app.get('/', (req, res) => {
    res.send('Aplikasi Express dengan Mongoose');
});

const PORT = 3000;
app.listen(PORT, () => console.log(`Server berjalan pada port ${PORT}`));

Saat server dijalankan, Express akan otomatis menghubungkan diri ke MongoDB sebelum menerima request.

6. Menjalankan Server

Jalankan server dengan:


node server.js

Atau jika menggunakan nodemon:


npx nodemon server.js

Jika koneksi berhasil, Anda akan melihat output:


$ npx nodemon server.js
[nodemon] 3.1.11
[nodemon] to restart at any time, enter `rs`
[nodemon] watching path(s): *.*
[nodemon] watching extensions: js,mjs,cjs,json
[nodemon] starting `node server.js`
Server berjalan pada port 3000
Berhasil terhubung ke MongoDB

7. Kesimpulan

Menghubungkan Express dengan MongoDB menggunakan Mongoose memberikan banyak keuntungan, terutama dalam hal struktur kode, validasi data, dan kemudahan penggunaan. Dengan memisahkan konfigurasi koneksi ke dalam file khusus, aplikasi menjadi lebih modular dan mudah dikembangkan. Langkah-langkah di atas dapat digunakan sebagai dasar dalam membangun aplikasi backend yang lebih kompleks termasuk penambahan model, controller, dan rute API.

untuk melihat artikel yang lain bisa klik Disiniuntuk versi yang menggunakan driver mongodb bisa lihat Disini

Tuesday, 25 November 2025

Install Prisma client versi 7.0.1 Pada Express JS

 

Prisma adalah next-generation ORM yang membantu developer bekerja dengan database secara efisien, aman, dan mudah. Prisma membuat proses query database menjadi lebih intuitif berkat Prisma Client yang dikompilasi otomatis dari schema yang kita definisikan. Pada artikel ini, kita akan membahas langkah-langkah instalasi Prisma Client pada aplikasi Express.js, mulai dari setup awal hingga siap digunakan.

1. Persiapan Lingkungan 

Sebelum memulai, pastikan Anda sudah menginstal beberapa hal berikut:

  • Node.js versi terbaru (minimal 14.x)
  • npm atau yarn 
  • Database yang akan digunakan, misalnya PostgreSQL, MySQL, SQLite, SQL Server atau MongoDB (dengan Prisma Mongo connector)

Pada saat artikel ini dibuat, saya menggunakan Node js versi 22.19.0,


express$ node -v
v22.19.0

Setelah semuanya siap, buat folder project baru dan lakukan inisialisasi: 


mkdir express
cd express
npm init -y

Selanjutnya install Express:


npm install express

Pada prisma client versi 7.0.1, kita akan menggunakan project typescript, karena jika menggunakan project js biasa akan bermasalah. 

2. Setup Project typescript

install dev-depedensi yang diperlukan:


npm install @types/express @types/node tsx typescript --save-dev

Selanjutnya ketikan


npx tsc --init

Buka file tsconfig.json dan ubah menjadi seperti ini:


{
  // Visit https://aka.ms/tsconfig to read more about this file
  "compilerOptions": {
    // File Layout
    "rootDir": "./src",
    "outDir": "./dist",
    // Environment Settings
    // See also https://aka.ms/tsconfig/module
    "module": "esnext",
    "target": "es2023",
    "types": [],
    // For nodejs:
    // "lib": ["esnext"],
    // "types": ["node"],
    // and npm install -D @types/node

    // Other Outputs
    "sourceMap": true,
    "declaration": true,
    "declarationMap": true,

    // Stricter Typechecking Options
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true,

    // Style Options
    // "noImplicitReturns": true,
    // "noImplicitOverride": true,
    // "noUnusedLocals": true,
    // "noUnusedParameters": true,
    // "noFallthroughCasesInSwitch": true,
    // "noPropertyAccessFromIndexSignature": true,

    // Recommended Options
    "strict": true,
    "jsx": "react-jsx",
    "verbatimModuleSyntax": true,
    "isolatedModules": true,
    "noUncheckedSideEffectImports": true,
    "moduleDetection": "force",
    "skipLibCheck": true,
    "moduleResolution": "node",
    "esModuleInterop": true,
  },
  "include": ["src/**/*"],
    "exclude": ["node_modules", "dist"],
}

Kemudian ubah juga file package.json, tambahkan type module


"type": "module",
  "keywords": [],
  

3. Menginstal Prisma dan Setup Awal

Prisma terdiri dari dua paket utama: Prisma CLI dan Prisma Client. CLI digunakan untuk mengelola schema, migrasi, dan utility lainnya, sedangkan Prisma Client digunakan di dalam kode Express. 

Install Prisma CLI dan yang lainya sebagai dev-depedensi:


npm install prisma --save-dev

Install juga depedensi yang lain 


npm install @prisma/adapter-mariadb @prisma/client dotenv

Setelah itu lakukan inisialisasi Prisma:


npx prisma init

Command ini akan menghasilkan folder baru bernama prisma/ yang berisi file schema.prisma. Selain itu Prisma akan membuat file .env yang digunakan untuk menyimpan variabel lingkungan, salah satunya koneksi database.

berikut versi prisma yang saya pakai:


express$ npx prisma -v
Loaded Prisma config from prisma.config.ts.

Prisma schema loaded from prisma/schema.prisma
prisma               : 7.0.1
@prisma/client       : 7.0.1
Operating System     : linux
Architecture         : x64
Node.js              : v22.19.0
TypeScript           : 5.9.3 

3. Mengatur Koneksi Database 

Buka file .env dan sesuaikan DATABASE_URL dengan database yang akan digunakan. Contoh jika menggunakan Mysql: 


DATABASE_URL="mysql://root:123@localhost:3306/belajar"

contoh diatas menggunakan database mysql, username=root, dan password mysqlnya adalah 123, dan nama databasenya adalah belajar, sesuaikan dengan pengaturan database kalian pada komputer atau laptop.

4. Membuat Schema Prisma

Buka file prisma/schema.prisma. Pastikan isinya seperti berikut:


generator client {
  provider = "prisma-client"
  output   = "../src/generated/prisma"
}

datasource db {
  provider = "mysql"
}

jika kalian menggunakan text editor Visual Studio Code, dan melihat baris merah pada bagian datasource db{provider="mysql"}, biarkan saja, karena pada versi sebelumnya ada tambahan url. itu bukan berarti error, itu hanya tatacara penulisan yang dianggap salah oleh text editornya.

Selanjutnya, Contoh sederhana untuk membuat model User:


generator client {
  provider = "prisma-client"
  output   = "../src/generated/prisma"
}

datasource db {
  provider = "mysql"
}

model users {
  id    Int     @id @default(autoincrement())
  name  String
  email String  @unique
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
 }

Setelah membuat schema, jalankan migrasi:


npx prisma migrate dev --name create_table_users

maka akan membuat sebuat folder didalam prisma/migrations, dan membuat table pada database dengan nama users.

Jika Error


Loaded Prisma config from prisma.config.ts.

Prisma schema loaded from prisma/schema.prisma
Datasource "db": MySQL database "belajar" at "localhost:3306"

- Drift detected: Your database schema is not in sync with your migration history.

The following is a summary of the differences between the expected database schema given your migrations files, and the actual schema of the database.

It should be understood as the set of changes to get from the expected schema to the actual schema.

[+] Added tables
  - users

- The following migration(s) are applied to the database but missing from the local migrations directory: 20251126045630_create_table_users

We need to reset the MySQL database "belajar" at "localhost:3306"

You may use prisma migrate reset to drop the development database.
All data will be lost.

Jalankan npx prisma migrate reset, dan ulangi lagi 


npx prisma migrate dev --name create_table_users

Setelah itu jalankan prisma generate


npx prisma generate

5. Menggunakan Prisma Client pada Express.js

Buat folder src dan buat file didalam folder src index.ts sebagai server Express:


import "dotenv/config";
import express from 'express';
import { PrismaMariaDb } from '@prisma/adapter-mariadb';
import { PrismaClient } from "./generated/prisma/client";

const app = express();
const adapter = new PrismaMariaDb({
  host: "localhost",
  user: "root",
  password: "123",
  database: "belajar",
  connectionLimit: 5
});
const prisma = new PrismaClient({ adapter });

app.use(express.json());

// Route: menambahkan user
app.get('/add-user', async (req, res) => {
  const name = "Naruto Uzumaki";
  const email = "naruto@konoha.com";
  const user = await prisma.users.create({
    data: { name, email }
  });
  res.json(user);
});

// Route: mendapatkan semua user
app.get('/user', async (req, res) => {
  const users = await prisma.users.findMany();
  res.json(users);
});

app.get('/', (req, res) => {
  res.send('Hello World!');
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

Aplikasi Anda sekarang sudah terhubung dengan Prisma dan siap melakukan query database dengan sintaks yang clean dan modern.

jalankan server dengan perintah pada terminal : 


npx tsx src/index.ts

akses browser dengan localhost:3000/add-user, untuk menambah user tetapi jangan di akses lebih 1 kali karna akan error, ini disebabkan karna email pada database harus unique tidak boleh sama jadi solusinya ubah dulu emailnya baru jalankan lagi routenya, untuk melihat list user akses dengan localhost:3000/user

Kesimpulan 

Instalasi Prisma Client pada Express.js tidaklah sulit. Dengan beberapa langkah mulai dari inisialisasi project, setup schema, migrasi, hingga penggunaan Prisma Client di dalam routing Express, Anda bisa mendapatkan ORM yang powerful dan mudah digunakan. Prisma memberikan banyak keuntungan seperti pengetikan yang kuat (type safety), auto-completion, dan struktur query yang rapi sehingga meningkatkan produktivitas developer.

Dengan mengikuti panduan di atas, sekarang Anda sudah dapat membangun aplikasi Express dengan akses database yang lebih efisien menggunakan Prisma.

Untuk melihat artikel yang lain, bisa klik Disini

Sunday, 23 November 2025

Kelebihan dan Kekurangan Hono JS untuk Pengembangan Web Modern

 

Dunia pengembangan web semakin berkembang dengan cepat, terutama pada ranah serverless dan edge computing. Salah satu framework yang sedang naik daun dalam kategori ini adalah Hono JS, sebuah framework web super ringan dan berperforma tinggi yang dirancang untuk berjalan di berbagai runtime seperti Cloudflare Workers, Deno, Bun, Vercel Edge Functions, dan Node.js. Dengan desain minimalis serta API yang intuitif, Hono menjadi pilihan menarik bagi developer yang menginginkan solusi cepat, sederhana, dan efisien.

Namun, seperti teknologi lainnya, Hono tidak hanya memiliki kelebihan tetapi juga kekurangan yang perlu dipertimbangkan sebelum memilihnya untuk proyek nyata. Artikel ini akan membahas keduanya secara menyeluruh agar kamu bisa menentukan apakah Hono cocok untuk kebutuhan pengembanganmu.

Apa itu Hono JS? 

Hono adalah framework web micro yang berfokus pada performa dan portabilitas. Pendekatannya mirip dengan Express dalam hal kemudahan penggunaan, tetapi sangat berbeda dalam hal performa dan target runtime. Dengan ukuran yang sangat kecil—bahkan hanya beberapa kilobyte—Hono mampu memberikan kecepatan routing yang tinggi dan pengalaman developer yang sangat nyaman.

Kelebihan Hono JS 

1. Super Cepat dan Efisien 

Salah satu nilai jual terbesar Hono adalah performa luar biasa dalam hal routing dan eksekusi. Karena dirancang untuk berjalan di environment edge seperti Cloudflare Workers, Hono dioptimalkan untuk startup time yang sangat rendah dan eksekusi yang cepat. Bagi aplikasi yang membutuhkan latency minimal, Hono adalah pilihan ideal.

2. Sangat Ringan (Lightweight) 

Hono memiliki ukuran sangat kecil dibandingkan framework web lainnya. Hal ini membuat deploy lebih cepat dan konsumsi resource lebih minim. Pada platform edge, ukuran yang ringan menjadi poin penting karena setiap byte memengaruhi kecepatan cold start.

3. Mendukung Banyak Runtime 

Tidak seperti framework tradisional yang terikat pada Node.js, Hono mendukung berbagai runtime modern seperti:

Kemampuan ini menjadikan Hono sangat fleksibel dan future-proof.

4. API yang Modern dan Mudah Dipahami 

Hono menawarkan API yang sangat mirip dengan standar Web API seperti Request dan Response. Contoh routing sederhana:


import { Hono } from 'hono'

const app = new Hono()

app.get('/', (c) => c.text('Hello Hono!'))

export default app

Sederhana, clean, dan langsung bisa digunakan tanpa konfigurasi rumit.

5. Cocok untuk Aplikasi Serverless dan Edge 

Hono sangat cocok untuk aplikasi yang berjalan di edge, seperti API mikro, personal dashboard, atau layanan caching. Dengan waktu startup cepat dan konsumsi resource kecil, Hono menjadi solusi yang unggul untuk arsitektur modern.

6. Dokumentasi yang Jelas dan Komunitas yang Tumbuh Pesat 

Walaupun relatif baru, Hono memiliki dokumentasi lengkap dan contoh implementasi yang mudah dipahami. Komunitasnya juga berkembang cepat, terutama di kalangan developer yang fokus pada cloud-native.

Kekurangan Hono JS 

1. Ekosistem Belum Seluas Express atau NestJS 

Sebagai framework baru, ekosistem Hono masih kalah jauh dari Express, Koa, Fastify, atau NestJS. Perpustakaan dan middleware khusus Hono masih terbatas, meskipun jumlahnya terus bertambah. Untuk proyek besar yang membutuhkan banyak plugin siap pakai, Hono mungkin belum ideal.

2. Terlalu Fokus pada Edge Runtime 

Walau mendukung Node.js, Hono sebenarnya dirancang terutama untuk platform edge. Jika proyekmu murni berjalan pada server traditional atau aplikasi monolit besar, framework seperti Fastify atau Express mungkin menawarkan kenyamanan lebih.

3. Belum Cocok untuk Arsitektur Kompleks 

Hono sangat bagus untuk API kecil hingga medium. Namun untuk arsitektur enterprise yang memerlukan modularisasi besar, dependency injection, atau manajemen lifecycle aplikasi yang lebih kompleks, Hono bisa terasa terlalu minimalis.

4. Sedikit Learning Curve untuk Developer Tradisional 

Karena menggunakan Web Standard API secara penuh, developer yang sudah terbiasa dengan gaya Node.js klasik mungkin perlu waktu untuk menyesuaikan diri, terutama dalam hal request/response handling.

Kesimpulan 

Hono JS adalah framework modern yang membawa pendekatan baru ke dunia pengembangan web: cepat, ringan, minimalis, dan sangat kompatibel dengan berbagai platform serverless dan edge. Kelebihannya menjadikannya ideal untuk aplikasi yang membutuhkan performa tinggi, latency rendah, dan footprint kecil.

Namun, Hono bukan solusi sempurna untuk semua kasus. Ekosistem yang belum matang dan minimnya fitur untuk arsitektur skala besar menjadikannya lebih cocok untuk aplikasi kecil hingga menengah atau microservices modern.

Jika kamu ingin mengembangkan API cepat dan efisien, terutama di platform edge seperti Cloudflare Workers atau Bun, Hono merupakan pilihan yang sangat kuat. Tetapi untuk aplikasi besar dan kompleks, framework yang lebih matang tetap menjadi opsi yang lebih aman.

Untuk melihat artikel yang lain, bisa klik Disini 

Perbandingan Bun.js vs Node.js vs Deno Mana yang Terbaik untuk Proyekmu

 

Dunia JavaScript terus berkembang, dan semakin banyak alat yang hadir untuk membantu developer membangun aplikasi dengan lebih cepat, aman, dan efisien. Tiga runtime JavaScript yang saat ini paling banyak dibicarakan adalah Node.js, Deno, dan Bun.js. Masing-masing menawarkan filosofi, fitur, dan pendekatan berbeda dalam menyelesaikan masalah klasik di ekosistem JavaScript.

Namun, muncul pertanyaan penting: runtime mana yang paling cocok untuk proyekmu? Jika kamu masih bingung memilih, artikel ini akan membandingkan ketiga runtime tersebut dari berbagai aspek: performa, fitur bawaan, keamanan, ekosistem, dan kemudahan pengembangan. Dengan memahami perbedaan dan kelebihan masing-masing, kamu bisa menentukan mana yang paling sesuai untuk kebutuhan proyekmu. 

1. Filosofi dan Latar Belakang

Node.js 

Dirilis pada 2009, Node.js adalah runtime JavaScript pertama yang populer di luar browser. Node menggunakan mesin V8 milik Chrome dan dikenal dengan ekosistem NPM yang sangat besar. Fokus utama Node adalah stabilitas dan ekstensibilitas.

Deno

Deno dirilis oleh Ryan Dahl—pencipta Node.js—sebagai “penyempurnaan” Node. Deno memperbaiki masalah arsitektur Node seperti keamanan default, dependency yang lebih jelas, dan penggunaan TypeScript tanpa konfigurasi tambahan.

Bun.js 

Bun adalah pemain baru yang berfokus pada kecepatan ekstrem dan penggabungan banyak alat dalam satu paket. Bun menggunakan mesin JavaScriptCore dari WebKit dan mengintegrasikan bundler, transpiler, package manager, serta server HTTP dalam satu runtime.

2. Performa 

Jika berbicara tentang performa, Bun saat ini menjadi sorotan utama.

Node.js 

Node cukup cepat, terutama untuk aplikasi berskala besar. Namun, beberapa operasi seperti bundling dan instalasi paket relatif lambat dibanding alat modern.

Deno 

Deno lebih cepat daripada Node dalam beberapa kasus, terutama terkait startup time dan pengelolaan dependency. Meski begitu, performanya tidak selalu mengungguli Bun.

Bun.js 

Bun dikenal sebagai runtime JavaScript paling cepat saat ini pada banyak benchmark:

  • startup time
  • kecepatan HTTP server
  • performa bundling
  • instalasi package

Bun mengoptimalkan banyak hal dari level rendah sehingga memberikan performa mengesankan.

3. Fitur Bawaan 

Fitur Node.js Deno Bun.js
Runtime JavaScript
Bundler ✖ (butuh alat eksternal)
Transpiler (TS/JSX)
Package Manager npm bawaan bawaan (bun install)
Keamanan default
Test Runner bawaan ✔ (modern)

Dari tabel ini terlihat bahwa Bun dan Deno lebih lengkap secara built-in, sementara Node lebih mengandalkan ekosistem eksternal.

4. Keamanan 

Node.js : Tidak memiliki sandbox atau izin default. Script dapat mengakses file system dan network secara bebas.

Deno : Keamanan adalah keunggulan utama Deno. Tanpa izin eksplisit, Deno tidak mengizinkan akses ke file, env, maupun network.

Bun.js : Saat ini keamanan bukan fokus utama Bun. Ia mengikuti pendekatan yang lebih mirip Node.

Untuk proyek yang sensitif terhadap keamanan, Deno adalah pilihan yang paling tepat.

5. Ekosistem dan Kompatibilitas 

Node.js : Memiliki ekosistem terbesar berkat NPM. Hampir semua library modern mendukung Node.

Deno : Meski berkembang, ekosistem Deno masih kecil. Namun mendukung modul ECMAScript langsung via URL.

Bun.js : Bun kompatibel dengan modul Node, termasuk Express dan Prisma, sehingga lebih mudah diadopsi. Namun, beberapa package Node yang kompleks masih belum berjalan sempurna.

Jika kompatibilitas ekosistem adalah prioritas, Node.js tetap unggul.

6. Kemudahan Pengembangan 

Node.js : Kuat, stabil, dan dokumentasinya sangat lengkap. Namun membutuhkan banyak alat eksternal untuk hal-hal seperti bundling dan transpiling.

Deno : Sangat developer-friendly, terutama untuk proyek yang mengandalkan TypeScript.

Bun JS : Bun menawarkan pengalaman paling sederhana karena semua alat sudah ada dalam satu runtime. Setup proyek menjadi sangat cepat.

Developer yang ingin serba praktis dan cepat kemungkinan akan menyukai Bun.js.

7. Kapan Menggunakan Masing-Masing? 

Pilih Node.js jika:

  • kamu membangun aplikasi skala besar
  • perlu kompatibilitas maksimal
  • butuh stabilitas jangka panjang

Pilih Deno jika:

  • keamanan menjadi prioritas
  • kamu bekerja dengan TypeScript secara intensif
  • kamu ingin ekosistem modern dan lebih bersih

Pilih Bun.js jika:

  • kamu ingin performa terbaik saat ini
  • butuh setup proyek yang super cepat
  • ingin runtime all-in-one tanpa konfigurasi rumit

Kesimpulan

Tidak ada runtime yang benar-benar “terbaik.” Pilihan tergantung kebutuhan proyekmu. Node unggul dalam stabilitas dan ekosistem, Deno unggul dalam keamanan dan pengalaman TypeScript, sementara Bun memberikan performa dan kemudahan luar biasa melalui pendekatan all-in-one.

Jika kamu ingin mencoba runtime modern yang cepat dan efisien, Bun bisa menjadi pilihan menarik. Namun, untuk aplikasi mission-critical berskala besar, Node.js masih menjadi raja di industri.

Untuk melihat artikel lain, bisa klik Disini 

Fitur, Kelebihan, dan Keterbatasan Bun JS

 

Bun.js merupakan salah satu runtime JavaScript generasi terbaru yang semakin menarik perhatian para developer karena kecepatan, fitur bawaan, dan pendekatannya yang all-in-one. Dibangun di atas mesin JavaScript JavaScriptCore (yang juga digunakan oleh Safari), Bun hadir sebagai alternatif yang lebih cepat dibandingkan runtime seperti Node.js maupun Deno. Namun, nilai utama Bun bukan hanya soal performa, melainkan juga ekosistem yang dibawanya, yang dirancang untuk menyederhanakan pengalaman developer secara menyeluruh.

Artikel ini membahas ekosistem Bun.js, termasuk fitur andalan, kelebihan, serta keterbatasan yang perlu dipertimbangkan sebelum menggunakannya dalam proyek nyata.

1. Fitur Utama dalam Ekosistem Bun.js 

    a. Runtime JavaScript Berperforma Tinggi 

Bun menawarkan performa yang sangat cepat dalam eksekusi JavaScript, terutama pada cold start dan operasi I/O. Hal ini dimungkinkan berkat penggunaan JavaScriptCore yang lebih ringan dan optimasi mendalam pada banyak operasi.

    b. Bundler, Transpiler, dan Minifier Bawaan 

Salah satu pembeda terbesar Bun adalah kemampuannya untuk melakukan bundling, transpiling, serta minifying hanya dengan satu tool. Bun bisa menangani TypeScript, JSX, TSX, dan bahkan file CSS tanpa perlu konfigurasi tambahan.

Sebagai contoh, proses yang biasanya membutuhkan webpack, Babel, atau esbuild kini bisa digantikan langsung oleh Bun. Dengan begitu, waktu setup proyek jadi jauh lebih cepat. 

    c. Package Manager super cepat 

Bun memiliki package manager bernama bun install, yang diakui sebagai salah satu yang paling cepat di antara tool serupa. Instalasi dependensi berlangsung signifikan lebih cepat dibandingkan npm maupun yarn, karena Bun menggunakan format cache yang efisien dan paralelisasi yang agresif.

    d. Server HTTP built-in 

Bun menyediakan API HTTP bawaan yang siap digunakan tanpa dependensi tambahan. Dengan API yang mirip dengan fetch dan Web Standard, developer bisa membuat server dengan sangat mudah:


Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hello from Bun!");
  }
});

Ini menjadikan Bun sangat menarik untuk pengembangan backend ringan maupun proyek prototipe.

    e. Kompatibilitas dengan Ekosistem Node.js 

Bun berusaha kompatibel dengan sebagian besar modul Node.js, termasuk fs, path, buffer, dan sebagainya. Bahkan banyak paket populer seperti Express, React, Fastify, dan Prisma dapat berjalan di Bun tanpa konfigurasi khusus.

2. Kelebihan Ekosistem Bun.js

    a. One-tool for everything

Dalam satu instalasi, Bun sudah mencakup:

  • runtime JavaScript
  • bundler
  •  transpiler
  • package manager
  • test runner
  • server HTTP

Pendekatan ini membuat workflow pengembangan lebih sederhana dan mengurangi ketergantungan pada alat eksternal.

    b. Performa cepat di berbagai aspek

Mulai dari menjalankan script, melakukan bundling, hingga instalasi paket, kecepatan Bun menjadi salah satu alasan utama banyak developer mencobanya. Ini sangat bermanfaat bagi aplikasi yang membutuhkan cold start rendah, seperti serverless.

    c. Developer experience yang modern

API Bun dirancang mengikuti standar web modern. Hal ini membuat developer front-end mudah beradaptasi ketika mengerjakan backend.

    d. Footprint lebih kecil

Karena menggunakan JavaScriptCore, Bun cenderung lebih ringan dibandingkan runtime lain. Ini juga berpotensi mengurangi konsumsi resource di server.

3. Keterbatasan Ekosistem Bun.js

Walaupun menjanjikan, Bun tetap memiliki sejumlah batasan:

    a. Belum 100% kompatibel dengan seluruh ekosistem Node.js

Beberapa modul Node, terutama yang sangat bergantung pada native bindings, masih belum berjalan sempurna. Meski kompatibilitasnya terus meningkat, migrasi proyek kompleks kadang memerlukan penyesuaian.

    b. Dokumentasi dan community belum sebesar Node.js

Sebagai proyek baru, dokumentasinya masih berkembang dan jumlah komunitasnya belum sebesar Node atau Deno. Hal ini dapat menyulitkan ketika mencari solusi dari error tertentu.

    c. Stabilitas pada aplikasi besar

Meskipun cepat, beberapa developer melaporkan bahwa Bun masih mengalami ketidakstabilan pada skala besar atau kasus edge tertentu. Hal ini wajar mengingat Bun masih berusia relatif muda dalam ekosistem JavaScript.

    d. Kurang cocok untuk proyek yang bergantung pada ekosistem NPM lawas 

Aplikasi lama dengan dependensi Node yang kompleks mungkin lebih stabil bila tetap di Node.js, kecuali jika paket yang digunakan sudah teruji berjalan baik di Bun.

Kesimpulan

Ekosistem Bun.js menawarkan pengalaman pengembangan yang serba cepat, praktis, dan modern. Dengan berbagai alat bawaan mulai dari bundler hingga package manager, Bun menghadirkan pendekatan all-in-one yang menghapus banyak kerumitan dalam workflow JavaScript tradisional. Namun, sebagai teknologi yang relatif baru, Bun masih memiliki keterbatasan pada kompatibilitas modul tertentu dan stabilitas aplikasi besar.

Bun sangat cocok untuk developer yang ingin mencoba teknologi modern, membuat prototipe cepat, atau membangun aplikasi dengan kebutuhan performa tinggi. Meski begitu, untuk proyek kritis yang kompleks, penting mempertimbangkan dengan matang kesiapan ekosistemnya.

Untuk melihat artikel yang lain, bisa klik Disini

Saturday, 22 November 2025

Arsitektur dan Fitur Unggulan Hono JS yang Wajib Diketahui

Hono JS muncul sebagai salah satu framework web modern yang dirancang dengan fokus pada kecepatan, fleksibilitas, dan kemudahan penggunaan. Meski tergolong baru dibandingkan framework JavaScript lainnya, Hono berhasil menarik perhatian banyak developer berkat pendekatannya yang minimalis namun sangat efisien. Framework ini dirancang agar dapat berjalan di berbagai runtime seperti Cloudflare Workers, Bun, Deno, NodeJs, dan platform edge lainnya. Untuk memahami mengapa Hono menjadi begitu populer, penting untuk mengetahui bagaimana arsitekturnya dibangun serta fitur-fitur unggulannya.

Artikel ini akan membahas arsitektur inti Hono JS dan fitur kunci yang membuatnya menonjol di ekosistem backend JavaScript modern.

1. Arsitektur Minimalis dan Modular 

Salah satu kekuatan terbesar Hono terletak pada arsitekturnya yang sangat minimalis. Framework ini dibangun dengan ukuran yang kecil, sehingga mampu menghasilkan waktu load yang cepat dan konsumsi memori yang rendah. Hono tidak mencoba menjadi framework serbaguna dengan fitur yang terlalu banyak. Sebaliknya, Hono menyediakan komponen inti yang ramping, sementara fitur tambahan tersedia melalui middleware eksternal. 

Pendekatan modulernya memungkinkan developer hanya menambahkan fitur yang dibutuhkan tanpa membawa “beban” tambahan. Ini sangat berbeda dengan framework yang membawa banyak fitur bawaan meskipun tidak semuanya diperlukan.

Minimalisme ini juga membantu Hono tetap konsisten di berbagai runtime—suatu hal yang jarang dimiliki framework lain.

2. Berbasis Standar Web (Web Standard API) 

Hono dibangun di atas Web Standard API, seperti Request, Response, dan fetch(). Dengan demikian, kode yang Anda tulis di Hono lebih kompatibel, mudah dipindahkan, dan bekerja secara konsisten pada berbagai platform.

Pendekatan ini memberikan dua keuntungan utama:

  • Developer tidak perlu mempelajari API baru yang rumit.
  • Aplikasi dapat berjalan di lingkungan serverless dan edge computing tanpa perubahan signifikan.

Arsitektur berbasis standar ini merupakan alasan utama mengapa Hono dapat berjalan dengan mulus di Cloudflare Workers, Vercel Edge Functions, dan runtime lain yang tidak murni berbasis Node.js.

3. Routing yang Sederhana dan Elegan

Routing adalah inti dari framework web apa pun, dan Hono menyajikannya dengan cara yang sangat bersih dan intuitif. Dengan pola deklaratif, developer dapat mendefinisikan route dengan cepat tanpa boilerplate panjang.

Contoh sederhana:


import { Hono } from 'hono'
const app = new Hono()

app.get('/', (c) => c.text('Hello from Hono!'))

Pendekatan ini membuat codebase tetap rapi seraya memberikan fleksibilitas dalam menangani berbagai metode HTTP, dynamic route, dan grouping route.

4. Performa Tinggi di Berbagai Runtime 

Hono dikenal sebagai salah satu framework tercepat di kategori JavaScript backend. Kecepatan ini berasal dari arsitektur minimalis dan optimalisasi berdasarkan environment tempat ia berjalan.

Beberapa alasan mengapa performa Hono sangat tinggi:

  • Menghindari abstraksi berlebih
  • Memanfaatkan Web Standard API yang ringan
  • Optimasi khusus untuk platform seperti Bun dan Cloudflare Workers
  • Tidak ada overhead middleware yang tidak digunakan

Di banyak benchmark, Hono konsisten berada di peringkat atas bersama framework berperforma tinggi lainnya.

5. Middleware yang Kaya dan Terstruktur

Walaupun ringan, Hono tidak ketinggalan fitur. Ekosistem middleware-nya sudah mencakup:

  • JWT Auth
  • Validasi dengan Zod
  • Logging
  • CORS
  • Rate limiting
  • OAuth
  • Session Management

Semua middleware ini dirancang dengan prinsip modular sehingga mudah diintegrasikan. Developer dapat memilih hanya middleware yang dibutuhkan, menjaga performa tetap optimal.

6. Mendukung Edge Computing Secara Native

Salah satu keunggulan unik Hono adalah optimasinya untuk edge computing. Banyak aplikasi modern membutuhkan latency rendah, dan Hono dirancang sejak awal untuk bekerja secara efisien di edge network.

Keunggulannya antara lain:

  • Boot time sangat cepat
  • Performa konsisten di serverless function
  • Cocok untuk microservices dan API gateway ringan

Dengan dunia yang semakin bergerak ke arah arsitektur serverless dan edge, Hono berada pada posisi yang sangat strategis.

Kesimpulan

Arsitektur Hono JS yang minimalis, modern, dan berbasis standar menjadikannya salah satu framework paling relevan untuk pengembangan backend masa kini. Fleksibilitas lintas runtime, performa yang luar biasa, serta ekosistem middleware yang terus berkembang membuatnya menjadi pilihan ideal untuk aplikasi modern—baik itu microservices, API ultra cepat, maupun proyek serverless berbasis edge.

Bagi developer yang mencari framework cepat, ringan, dan masa depan, Hono adalah pilihan yang sangat layak dipertimbangkan.

Untuk melihat artikel yang lain bisa klik Disini 

Perbandingan Hono JS vs Express: Siapa yang Lebih Unggul?

 

Dalam dunia pengembangan backend JavaScript, Express telah lama menjadi standar de facto untuk membangun REST API maupun server web. Namun, beberapa tahun terakhir bermunculan framework baru yang menawarkan performa lebih tinggi dan pengalaman developer yang lebih modern—salah satunya adalah Hono JS. Framework minimalis yang dirancang untuk berjalan di berbagai environment seperti Cloudflare Workers, Bun, Deno, dan Node.js ini mulai menarik perhatian banyak developer. Pertanyaannya: apakah Hono mampu menyaingi dominasi Express?

Artikel ini akan membahas perbandingan keduanya dari sisi performa, fleksibilitas, kemudahan penggunaan, ekosistem, serta potensi penggunaan di masa depan. 

1. Performa 

Salah satu daya tarik utama Hono JS adalah performanya yang luar biasa cepat. Hono dibangun dengan pendekatan minimalis dan dioptimalkan untuk platform edge, membuatnya sangat ringan dan efisien. Benchmark independent menunjukkan bahwa Hono mampu melayani request per detik jauh lebih tinggi dibanding Express, terutama pada platform seperti Bun dan Cloudflare Workers.

Express, meskipun stabil dan mature, memiliki performa lebih rendah karena arsitekturnya yang lebih tua dan banyak middleware bawaan yang menambah overhead. Untuk aplikasi dengan kebutuhan throughput sangat tinggi, Hono jelas menjadi kandidat yang lebih unggul.

Kesimpulan:

Hono menang dalam performa mentah dan efisiensi.

2. Kemudahan Penggunaan

Express terkenal dengan API yang sederhana dan intuitif. Banyak developer JavaScript pertama kali belajar backend melalui Express karena strukturnya mudah dipahami, dokumentasinya lengkap, dan banyak tutorial tersedia.  

Menariknya, Hono juga mengadopsi kesederhanaan yang mirip, namun dengan pendekatan yang lebih modern. Routing di Hono terasa lebih bersih dan deklaratif. Contohnya:


import { Hono } from 'hono'
const app = new Hono()

app.get('/hello', (c) => c.text('Hello Hono!'))
export default app

API routing ini mirip dengan Express, tetapi lebih ringan dan dirancang untuk bekerja secara optimal di berbagai runtime, bukan hanya Node.js.

Kesimpulan:

Keduanya mudah digunakan, namun Hono menawarkan pengalaman yang lebih modern dan fleksibel.

3. Ekosistem dan Middleware 

Di sinilah Express masih memimpin. Dengan usia lebih dari satu dekade, Express memiliki ekosistem middleware yang sangat kaya: autentikasi, body parser, validation, logging, dan masih banyak lainnya.

Hono memiliki ekosistem middleware yang terus berkembang, termasuk validasi berbasis Zod, JWT, OAuth, dan caching. Namun jumlahnya belum sebanyak Express. Meski demikian, Hono mampu memanfaatkan beberapa middleware standar karena mendukung Web Standard API.

Kesimpulan:

Express unggul dalam ekosistem, tetapi Hono terus mengejar dan sudah cukup matang untuk kebutuhan umum.

4. Kesesuaian Platform

Salah satu kelebihan terbesar Hono adalah fleksibilitasnya. Ia dapat berjalan di berbagai environment:

  • Cloudflare Workers
  • Bun
  • Deno  
  • Vercel Edge Functions
  • Node JS 

Express hanya berjalan pada Node.js. Untuk aplikasi yang memanfaatkan edge computing atau arsitektur serverless modern, Hono adalah pilihan yang jauh lebih baik. 

Kesimpulan:

Hono menang telak dalam kompatibilitas lintas platform.

5. Use Case

  • Gunakan Express jika: Anda bekerja dengan proyek legacy, membutuhkan middleware yang sangat spesifik, atau butuh stabilitas jangka panjang dengan ekosistem besar.
  • Gunakan Hono jika: Anda ingin performa maksimal, deployment serverless/edge, atau ingin memulai proyek baru dengan runtime modern seperti Bun atau Deno.

Kesimpulan Akhir 

Dalam banyak aspek, terutama performa dan fleksibilitas platform, Hono JS menunjukkan potensi besar untuk menjadi penerus Express di era modern. Meskipun ekosistemnya belum sebesar Express, fitur dan desainnya yang modern membuatnya sangat menarik bagi developer yang menginginkan performa tinggi dan kompatibilitas lintas runtime.

Jika Anda sedang memulai proyek baru, terutama yang membutuhkan kecepatan dan arsitektur serverless, Hono bisa menjadi pilihan terbaik. Namun untuk proyek matang yang sudah mengandalkan ekosistem Express, perpindahan tidak selalu diperlukan.

Keduanya tetap memiliki tempat masing-masing dalam dunia backend JavaScript, tetapi arah perkembangan industri menunjukkan bahwa framework seperti Hono akan semakin populer.

Jika ingin melihar artikel yang lain bisa di klik Disini

Wednesday, 19 November 2025

Instalasi Framework Hono JS dengan Bun js

 

Dalam beberapa tahun terakhir, ekosistem JavaScript terus berkembang dengan munculnya berbagai tool baru yang menawarkan performa lebih cepat dan pengalaman pengembangan yang lebih efisien. Salah satu yang paling populer adalah Bun, sebuah JavaScript runtime modern yang digerakkan oleh mesin Zig. Selain itu, ada pula Hono, sebuah web framework berperforma tinggi yang dirancang untuk serverless environment seperti Cloudflare Workers, Bun, Deno, hingga Node.js. Kombinasi Bun dan Hono menawarkan workflow yang sangat cepat, ringan, dan cocok untuk pengembangan API maupun aplikasi web modern.

Artikel ini akan membahas cara instalasi Bun, lalu melanjutkan dengan pembuatan project Hono menggunakan runtime Bun.

Apa Itu Bun? 

Bun adalah JavaScript runtime alternatif selain Node.js dan Deno. Beberapa keunggulan Bun antara lain:

  • Proses instalasi dan eksekusi sangat cepat
  • Memiliki paket manager bawaan (bun install)
  • Memiliki bundler dan transpiler bawaan
  • Kompatibel dengan sebagian besar ekosistem npm
  • Resource usage lebih efisien

Bun sangat cocok dipadukan dengan framework seperti Hono, yang memanfaatkan kecepatan runtime untuk membangun server yang ringan dan cepat.

Apa Itu Hono? 

Hono adalah web framework minimalis yang sangat cepat dan fleksibel. Framework ini dirancang untuk bekerja di berbagai runtime, terutama yang lightweight seperti Bun dan Cloudflare Workers. Beberapa keunggulan Hono: 

  • Super cepat (benchmark di atas framework tradisional seperti Express)
  • Ringan, ukuran kecil
  • Router canggih dengan penulisan deklaratif
  • Dukungan TypeScript
  • Mudah dipelajari karena syntax mirip Express

Dengan menggabungkan Bun dan Hono, developer dapat membangun REST API dengan performa yang sangat baik tanpa konfigurasi rumit.

1. Instalasi Bun

Unutk menginstall bun bisa dilihat Disini  

2. Instalasi Hono 

Hono dapat diinstal menggunakan paket manager bawaan Bun:


bun add hono

Setelah instalasi selesai, Anda siap membuat server API berbasis Hono.

3. Membuat Server Hono dengan Bun 

Buat file baru, misalnya index.js atau index.ts jika menggunakan TypeScript: 


import { Hono } from 'hono'
const app = new Hono()

app.get('/', (c) => c.text('Hono!'))

export default app

Pada contoh di atas, kita mendefinisikan satu rute GET yang akan menampilkan teks sederhana.

4. Menjalankan Server 

Jalankan server menggunakan perintah:


bun run index.js

selanjutnya buka browser dan akses http://localhost:3000/. jika berhasil akan ada pesan text Hono!.

Kesimpulan 

Instalasi Bun dan Hono adalah langkah ideal untuk developer yang mencari performa tinggi dan pengalaman pengembangan yang efisien. Bun sebagai runtime modern memberikan kecepatan luar biasa, sementara Hono menawarkan framework minimalis namun sangat bertenaga untuk membangun server API maupun aplikasi web modern. Dengan langkah instalasi yang sederhana dan workflow yang ringan, kombinasi Bun + Hono sudah cukup untuk membangun project skala kecil hingga besar dengan performa optimal.

Untuk melihat artikel yang lain bisa dicek Disini 

Membuat Project JavaScript dengan Bun

 

JavaScript telah menjadi bahasa pemrograman utama dalam pengembangan web modern, dan ekosistemnya terus berkembang dengan cepat. Salah satu alat terbaru yang menarik perhatian developer adalah Bun. Bun merupakan runtime JavaScript modern yang diklaim lebih cepat daripada Node.js dan Deno dalam berbagai kasus. Selain itu, Bun juga dilengkapi dengan package manager bawaan, bundler, dan transpiler, sehingga memudahkan pengembangan project JavaScript dari awal hingga produksi.

Dalam artikel ini, kita akan membahas langkah-langkah membuat project JavaScript menggunakan Bun, mulai dari instalasi hingga menjalankan project pertama Anda.

Apa itu Bun? 

Bun adalah runtime JavaScript yang ditulis menggunakan Zig dan menawarkan performa tinggi. Beberapa fitur utama Bun meliputi:

  • Runtime cepat: Bun mampu mengeksekusi JavaScript lebih cepat dibanding Node.js karena optimasi pada level mesin.
  • Package manager bawaan: Anda tidak perlu menggunakan npm atau yarn untuk mengelola dependencies. Bun sudah menyediakan bun install.
  • Bundler & Transpiler: Bun dapat langsung mengubah kode TypeScript atau JSX menjadi JavaScript yang siap dijalankan tanpa alat tambahan.
  • Ekosistem modern: Mendukung modul ES dan banyak fitur terbaru JavaScript secara default.

Instalasi Bun 

Sebelum membuat project, pastikan Bun sudah terinstal di sistem Anda. Bun mendukung macOS, Linux, dan Windows (melalui WSL atau terminal yang mendukung).

Untuk menginstal Bun, jalankan perintah berikut di terminal:


curl -fsSL https://bun.sh/install | bash

Setelah instalasi selesai, pastikan Bun terpasang dengan menjalankan:


bun -v


:$ bun -v
1.2.21

versi bun yang saya pakai saat artikel ini dibuat adalah 1.2.21. 

Membuat Project Baru dengan Bun

Setelah Bun terinstal, kita bisa membuat project JavaScript baru. Bun menyediakan template sederhana agar project bisa langsung dijalankan.

Langkah 1: Inisialisasi Project

Buat folder project baru, lalu masuk ke folder tersebut:  


mkdir my-bun-project
cd my-bun-project

Kemudian jalankan perintah untuk membuat project Bun baru:


bun init


bun init

? Select a project template - Press return to submit.
❯   Blank
    React
    Library
    

Pilih saja Blank dan enter

Biasanya, Bun akan membuat file index.js sebagai titik awal aplikasi Anda.

Menambahkan Dependencies 

Bun menggunakan bun install untuk mengelola dependencies. Misalnya, jika Anda ingin menambahkan library express (meskipun Bun menyarankan library modern seperti Fastify atau Bun HTTP), Anda bisa menjalankan:


bun add express

Bun secara otomatis membuat file bun.lockb dan mengatur dependencies Anda.

Menulis Kode JavaScript Pertama

Buka atau buat file index.js, dan tambahkan kode sederhana:  


import Bun from 'bun';

const server = Bun.serve({
  port: 3000,
  routes:{
    "/": () => new Response("Hello BUN!"),
  }
});

console.log(`Server running on ${server.url}`);

Jalankan server:


bun run index.ts


$ bun run index.ts
Server running on http://localhost:3000/

Kemudian buka browser dan akses http://localhost:3000/. Maka akan muncul Hello BUN!.

Kelebihan Menggunakan Bun untuk Project JavaScript

  • Kecepatan tinggi: Bun seringkali lebih cepat untuk eksekusi kode dan instalasi dependencies dibanding Node.js.
  • All-in-one: Tidak perlu bundler atau transpiler tambahan.
  • Mudah digunakan: Sintaks dan perintah mirip dengan Node.js, sehingga developer tidak perlu belajar ulang.
  • Modern: Mendukung ES Modules, TypeScript, dan JSX secara native.

Kesimpulan 

Bun menawarkan cara baru yang cepat dan efisien untuk mengembangkan aplikasi JavaScript. Dengan runtime yang ringan, package manager bawaan, serta kemampuan bundler dan transpiler, Bun mempermudah developer dalam memulai project dari nol. Dalam panduan ini, kita telah mempelajari cara menginstal Bun, membuat project baru, menambahkan dependencies, menjalankan kode sederhana, dan membuat server HTTP dasar.

Dengan terus berkembangnya Bun, kemungkinan besar di masa depan banyak proyek JavaScript modern akan memanfaatkan runtime ini untuk performa yang lebih optimal. Jadi, bereksperimen dengan Bun sekarang bisa menjadi langkah strategis bagi developer yang ingin tetap up-to-date dengan ekosistem JavaScript.

Untuk melihat artikel yang bersangkutan dengan javascript bisa dicek Disini 

Monday, 17 November 2025

Tutorial Routing di CodeIgniter 4 Basic hingga Advanced

 

Routing merupakan salah satu bagian terpenting dalam pengembangan aplikasi web menggunakan CodeIgniter 4. Dengan routing, kita dapat menentukan bagaimana sebuah URL dipetakan ke controller atau aksi tertentu. Tanpa routing yang tepat, aplikasi bisa menjadi tidak terstruktur, sulit dipelihara, dan rawan error. Pada artikel ini, kita akan membahas routing di CodeIgniter 4 mulai dari konsep dasar hingga penggunaan tingkat lanjut.

Apa Itu Routing di CodeIgniter 4? 

Routing adalah proses yang menghubungkan permintaan (request) dari user ke fungsi atau controller yang sesuai. Misalnya, ketika pengguna membuka URL example.com/home, maka router akan meneruskan permintaan itu ke controller Home dan menjalankan function index().

CodeIgniter 4 menggunakan file app/Config/Routes.php sebagai tempat utama untuk mendefinisikan semua route.

1. Routing Dasar (Basic Routing) 

    a. Route ke Controller

Contoh sederhana routing di CodeIgniter 4:


$routes->get('/', 'Home::index');

Kode tersebut berarti ketika pengguna mengakses URL root /, maka controller Home dengan method index() akan dijalankan.

    b. Route dengan Parameter

Kita juga dapat menangkap parameter dari URL:


$routes->get('blog/(:any)','Blog::detail/$1');

Penjelasan:

  • (:any) menangkap segalanya (string bebas) 
  • $1 merujuk ke parameter pertama

Contoh penggunaan:
example.com/blog/tutorial-codeigniter → diarahkan ke Blog::detail("tutorial-codeigniter") 

    c. Routing POST 

Untuk request POST:


$routes->post('user/login', 'User::login');

Ini berguna untuk form login, upload, atau proses lainnya.

2. Routing dengan Jenis Segment

CodeIgniter 4 menyediakan beberapa jenis wildcard:

 

Wildcard Fungsi
(:any) Menerima semua karakter
(:segment) Menerima segment URL tanpa slash
(:num) Hanya angka
(:alpha) Hanya huruf
(:alphanum) Huruf dan angka

Contoh:


$routes->get('product/(:num)', 'Product::detail/$1');

URL: /product/12 → OK
URL: /product/abc → Tidak cocok  

3. Routing ke Closure (Tanpa Controller)

Routing juga bisa langsung mengeksekusi function:


$routes->get('hello', function() {
	return "Hello World!"
});

Ini berguna untuk testing atau endpoint sederhana.

4. Route Grouping (Pengelompokan Route)

Untuk aplikasi besar, grouping sangat membantu menjaga kerapian. Contoh grouping:


$routes->group('admin', function($routes) {
	$routes->get('dashboard', 'Admin\Dashboard::index');
    $routes->get('users', 'Admin\Users::index');
})

Hasil URL:

  • /admin/dashboard
  • /admin/users  

Dengan grouping, struktur menjadi lebih rapi dan mudah dikelola.

5. Routing dengan Filter

Filter digunakan untuk validasi sebelum sebuah route dieksekusi, seperti autentikasi. Contoh:


$routes->group('admin', ['filter' => 'auth'], function($routes){
	$routes->get('panel', 'Admin\Panel::index');
});

Artinya: Semua route dalam grup admin harus melewati filter auth terlebih dahulu. ini sangat berguna untuk membuat sistem login. 

6. Auto Routing (Legacy & Improved)

CodeIgniter 4 menyediakan auto routing, tetapi penggunaannya harus hati-hati.

    a. Auto Routing Improved (Direkomendasikan)  

Aktifkan di App/Config/Feature.php


public bool $autoRoutesImproved = true;

Dengan fitur ini, URL otomatis mencocokkan controller tanpa deklarasi route.

    b. Auto Routing Legacy (Tidak Disarankan) 

egacy auto routing rawan celah keamanan dan beberapa fungsi tidak terkunci dengan baik.

7. Routing REST API

Membuat route untuk API sangat mudah:


$routes->resource('users');

Ini otomatis membuat route berikut:

  • GET /users
  • POST /users
  • GET /users/(:num)
  • PUT /users/(:num)
  • DELETE /users/(:num)

Fitur ini sangat membantu dalam pembuatan REST API secara cepat.

Kesimpulan

Routing di CodeIgniter 4 menawarkan fleksibilitas tinggi dan kemudahan dalam pengaturan arus navigasi aplikasi. Mulai dari routing dasar ke controller, penggunaan parameter, grouping, filter, hingga REST API, semuanya dirancang untuk memudahkan developer dalam membangun aplikasi yang cepat, aman, dan terstruktur.

Dengan memahami routing secara menyeluruh, proses pengembangan aplikasi akan menjadi lebih efisien dan mudah dipelihara. Jika kamu sedang membangun aplikasi berskala besar, penggunaan grouping dan filter sangat disarankan untuk menjaga kerapian dan keamanan struktur aplikasi. Hal lain yang perlu diperhatikan adalah penggunaan auto routing improved sebagai pengganti legacy demi keamanan aplikasi.  

untuk melihat artikel lain tentang Codeigniter 4 atau 3 bisa dilihat Disini

Membuat Middleware Sederhana dengan CodeIgniter 4


 

Dalam pengembangan aplikasi web modern, middleware menjadi komponen penting untuk menangani proses yang perlu dijalankan sebelum atau sesudah sebuah request diproses oleh controller. CodeIgniter 4, sebagai versi terbaru dari framework PHP populer ini, telah menyediakan fitur middleware (disebut Filters) yang memudahkan developer mengelola autentikasi, logging, pembatasan akses, dan berbagai kebutuhan pre-processing lainnya.

Pada artikel ini, kita akan membahas langkah-langkah membuat middleware sederhana di CodeIgniter 4, mulai dari struktur dasar hingga implementasinya.

Apa itu Middleware (Filter) di CodeIgniter 4?

Secara sederhana, middleware atau filter adalah lapisan yang menangani proses tertentu sebelum request diteruskan ke controller atau setelah controller menyelesaikan prosesnya. Filter ini dapat digunakan untuk:

  •  Memeriksa status login pengguna.
  •  Membatasi akses berdasarkan role.
  •  Logging aktivitas user.
  •  Menambahkan header khusus pada response.
  •  Mengamankan API.

CodeIgniter 4 menyediakan struktur filter yang mudah digunakan dan sangat fleksibel.

Langkah 1: Membuat Filter Baru 

CodeIgniter menyediakan perintah CLI untuk membuat filter dengan cepat, tetapi kita juga bisa melakukannya secara manual. 

Membuat file filter 

Buat file baru di: app/Filters/AuthFilter.php
Isi dengan kode berikut:

 

Filter di atas akan mengecek apakah session logged_in ada. Jika tidak, pengguna diarahkan ke halaman login. 

Langkah 2: Mendaftarkan Filter ke Config 

Agar filter bisa digunakan, kita harus mendaftarkannya ke file konfigurasi filter.

Buka file: app/Config/Filters.php
Tambahkan filter yang baru kita buat: 

 

Dengan begitu, filter kita sudah memiliki alias auth dan dapat digunakan pada route atau global filter.

Langkah 3: Membuat controller 

Buat controller pada folder controller misal Home.php isinya seperi ini:

 

Langkah 4: Menggunakan Filter pada Route

Filter bisa diterapkan pada route tertentu atau grup route. Contoh: menerapkan filter ke satu route.


$routes->get('/dashboard','Dashboard::index', ['filter'=> 'auth']);

Setiap kali route /dashboard diakses, filter auth akan dijalankan terlebih dahulu.

Contoh: menerapkan filter ke grup route


$routes->group('admin', ['filter'=> 'auth'],function($routes) {
	$routes->get('users','Admin\Users::index');
    $routes->get('settings','Admin\Settings::index');
});

Semua route dalam grup admin akan terlindungi oleh filter autentikasi.

untuk file routes.php jadi seperti ini

coba cek akses pada browser dengan mengakses localhost:8080/dashboard secara langsung maka akan di arahkan ke route login. selanjutnya coba buat session terlebih dahulu dengan mengakses route localhost:8080/create-session setelah itu coba akses lagi halaman dashboard maka akan berhasil.

Kesimpulan 

Middleware atau filter di CodeIgniter 4 merupakan fitur yang sangat bermanfaat untuk menangani proses yang harus dijalankan sebelum atau sesudah request diproses. Dengan filter, Anda bisa membuat logika autentikasi, pengamanan API, logging, dan berbagai kebutuhan lain dengan lebih rapi dan terstruktur.

Pada artikel ini, kita telah membahas:

  •  Cara membuat filter sederhana
  •  Cara mendaftarkan filter ke konfigurasi
  •  Cara menggunakannya pada route dan group route

Dengan memahami konsep ini, Anda dapat membangun aplikasi yang lebih aman, terorganisir, dan mudah dirawat.

untuk mmelihat artikel lain yang bersangkutan dengan Codeigniter, bisa dilihat disini.

Sunday, 16 November 2025

Memahami Struktur Folder CodeIgniter 4: Penjelasan Lengkap untuk Pemula

 

Struktur folder dalam sebuah framework adalah hal penting yang harus dipahami oleh setiap developer sebelum mulai membangun aplikasi. CodeIgniter 4 (CI4) hadir dengan struktur yang lebih rapi, modern, dan modular dibanding versi sebelumnya. Pemahaman mendalam mengenai struktur folder CI4 akan membantu Anda bekerja lebih efisien, lebih terorganisir, serta mempermudah proses maintenance aplikasi di masa mendatang. Artikel ini akan membahas secara detail fungsi setiap folder dalam CodeIgniter 4 sehingga pemula dapat memahami cara kerja framework ini dengan baik.

1. Gambaran Umum Struktur Folder CodeIgniter 4

Setelah Anda menginstal CodeIgniter 4, baik menggunakan Composer maupun manual, Anda akan menemukan beberapa folder utama seperti:


app/
public/
writable/
tests/
system/

Setiap folder memiliki peran spesifik. Ada yang digunakan untuk menyimpan kode aplikasi, public assets, file hasil upload, hingga file sistem inti CI4. Pemisahan ini memberikan keamanan dan struktur yang lebih jelas bagi developer.

2. Folder app/

Folder app adalah pusat utama aplikasi Anda. Semua logika bisnis, konfigurasi inti aplikasi, controller, model, view, hingga filter disimpan di sini.

Struktur folder di dalam app biasanya seperti berikut:

    a. app/Controllers

Folder ini menyimpan controller, yaitu komponen yang mengatur alur aplikasi.
Contohnya:


<?php

  namespace App\Controllers;
  
  class Home extends BaseController{
  	public function index(){
  		return view('welcome_message');
  	}
  }

Controller bertugas menerima request dan mengembalikan response.

    b. app/Models

Folder ini berisi model yang berfungsi untuk berinteraksi dengan database.
Misalnya:


<?php
   namespace App\Models;
   
   use CodeIgniter\Model;
   
   class UserModel extends Model{
      protected $table ='users';
   }
  

Model dapat melakukan operasi CRUD dan query builder.

    c. app/Views

Folder yang menyimpan file tampilan (HTML, PHP template).
Misalnya:
welcome_message.php

Views digunakan untuk menampilkan data ke pengguna.

    d. app/Config

Berisi file konfigurasi aplikasi seperti:

  • BaseURL
  • Filters
  • Database
  • Email
  • Routing

Ini adalah folder penting yang sering Anda ubah saat pengembangan aplikasi.

    e. app/Filters

Berisi filter seperti authentication, logging, atau middleware lain.

    f. app/Helpers

Tempat menaruh file helper custom (fungsi global yang dapat dipanggil dari mana saja).

3. Folder public/

Folder ini adalah document root aplikasi, artinya semua file di sini dapat diakses secara langsung oleh browser. Folder ini biasanya berisi:

  • index.php (entry point aplikasi)
  • Asset frontend seperti CSS, JS, gambar
  • File upload jika tidak dipindah ke writable

Tujuan folder ini adalah mencegah file sensitif di luar public agar tidak bisa diakses langsung dari internet, sehingga meningkatkan keamanan.

4. Folder writable/

Folder writable digunakan untuk menyimpan file yang dapat ditulis (writeable) oleh aplikasi.
Isinya bisa berupa:

  • cache/
  • debugbar/
  • logs/
  • uploads/
  • sessions/

Folder ini sangat penting untuk keperluan logging, caching, dan debugging selama pengembangan aplikasi.

CI4 memisahkan folder ini agar tidak tercampur dengan file sistem dan lebih aman saat deploy.

5. Folder system/

Folder system adalah inti dari framework CodeIgniter 4. Semua file penting yang membentuk CI4 berada di sini: class inti, helper bawaan, library, routing engine, dan banyak komponen internal lainnya.

Anda tidak dianjurkan mengubah file di folder ini, karena:

  1. Bisa merusak framework

  2. Akan tertimpa saat update versi

  3. Menyulitkan debugging

Jika perlu melakukan perubahan, gunakan extension melalui folder app atau app/Libraries.

6. Folder tests/

Folder ini dibuat untuk pengujian aplikasi menggunakan PHPUnit.
Jika Anda ingin menerapkan Test Driven Development (TDD), folder ini akan sangat bermanfaat untuk:

  • Unit testing
  • Feature testing
  • CI/CD pipeline

Meskipun pemula sering mengabaikannya, folder ini sangat penting untuk aplikasi berskala besar.

7. File .env

Selain folder, ada juga file .env yang digunakan untuk menyimpan konfigurasi environment seperti:

  • Mode development/production
  • Koneksi database
  • Email SMTP
  • Debug mode

File ini tidak dimasukkan ke GitHub (harus di-ignore) karena biasanya mengandung data sensitif seperti password database.

Kesimpulan

Struktur folder CodeIgniter 4 dirancang agar rapi, aman, dan modular. Dengan memahami fungsi setiap folder seperti app, public, writable, system, dan lainnya, Anda akan lebih mudah dalam mengembangkan aplikasi berbasis CI4. Pemahaman ini sangat penting terutama bagi pemula agar tidak salah menempatkan file dan mampu mengikuti best practice pengembangan aplikasi web.

untuk melihat topik yang bersangkutan dengan artikel ini bisa cek disini 

 

Panduan Belajar CodeIgniter 4 untuk Pemula dari Nol

 


CodeIgniter 4 (CI4) adalah salah satu framework PHP yang ringan, cepat, dan mudah dipelajari. Meskipun sederhana, CI4 memiliki struktur modern, mendukung arsitektur MVC, serta cocok digunakan untuk berbagai jenis aplikasi, mulai dari CRUD sederhana hingga API tingkat lanjut.

Panduan ini dirancang untuk membantu pemula memahami dasar CodeIgniter 4 mulai dari instalasi hingga pembuatan fitur sederhana.

1. Apa Itu CodeIgniter 4?

CodeIgniter 4 adalah versi terbaru dari framework CodeIgniter yang dirancang ulang agar lebih modern. Dibangun dengan standar PHP 7/8, mendukung PSR, dan menggunakan struktur directory yang lebih terorganisir.

Fitur Utama CI4

  • Lightweight & high performance
  • Arsitektur MVC
  • Routing modern
  • Built-in security (CSRF, XSS, Filters)
  • Query Builder & ORM-like model
  • Support CLI (spark)

2. Persyaratan Sebelum Menggunakan CI4

Sebelum mulai, pastikan sudah menginstal:
  • PHP 7.4 atau lebih baru, Composer,
  • Ekstensi PHP: intl, mbstring, json, xml, 
  • Web Server: Apache / Nginx (opsional jika pakai PHP development server)

3. Cara Install CodeIgniter 4

Install via Composer (Rekomendasi):


  composer create-project codeigniter4/appstarter ci4-app
  

Masuk ke folder:


  cd ci4-app

Jalankan development server:


  php spark serve

Buka browser:
http://localhost:8080

4. Struktur Folder CodeIgniter 4

CI4 memiliki struktur aplikasi seperti berikut:


  app/           → Folder utama aplikasi
  public/        → Akar public, tempat index.php
  app/Controllers → Menyimpan controller
  app/Models       → Model database
  app/Views        → Template View
  writable/       → Cache, logs, uploads

5. Memahami Konsep MVC di CI4

Model (M) => berhubungan dengan database.

View (V)  => menampilkan halaman html.

Controller (C)  => penghubung antara model dan view.

6. Membuat Controller Pertama

Buat file:
app/Controllers/Home.php


  <?php
  
  namespace App\Controllers;
  
  class Home extends BaseController{
     public function index(){
       return 'Hello dari CodeIgniter 4!';
     }
  }

Tambahkan routing di app/Config/Routes.php:


  <?php
  
  use CodeIgniter\Router\RouteCollection;
  /**
  *@var RouteCollection $routes
  */
  
  $routes->get('/','Home::index');

7. Membuat View Sederhana

Buat file:
app/Views/welcome.php


  <h1>Halo, Selamat Datang di CI4!</h1>
 

Gunakan view pada controller:


  <?php
  
  namespace App\Controllers;
  
  class Home extends BaseController{
    public function index(){
      return view('welcome');
    }
  }

8. Keamanan di CodeIgniter 4

CI4 menyediakan beberapa fitur:

  • CSRF protection

  • XSS filtering

  • Password hashing (Password::hash)

  • Filters (auth, rate limit, dll.)

 

Kesimpulan

CodeIgniter 4 adalah framework yang ideal untuk pemula maupun profesional. Dengan struktur MVC, CLI tools, dan fitur keamanan bawaan, CI4 memudahkan pembuatan aplikasi modern dengan cepat.

untuk melihat artikel yang berhubungan dengan Codeigniter 3 atau 4, bisa cek disini