Cara Memulai ElysiaJS dengan OpenAPI dan Bun di Tahun 2026

Memilih kerangka kerja yang tepat dapat membuat perbedaan besar dalam membangun API yang efisien dan terukur. ElysiaJS, sebuah kerangka kerja Node.js yang ringan, berpadu sangat baik dengan runtime berkinerja tinggi Bun dan standardisasi OpenAPI untuk dokumentasi serta pembuatan klien. Kombinasi ini menawarkan jalur yang efisien bagi pengembang untuk membuat layanan RESTful yang tangguh dengan biaya minimal. Karena API menjadi tulang punggung aplikasi modern, memulai dengan ElysiaJS, OpenAPI, dan Bun membekali Anda untuk menyediakan endpoint yang aman tipe (type-safe) dan terdokumentasi dengan baik secara cepat. Dalam panduan ini, kami akan membahas segala sesuatu mulai dari dasar-dasar ElysiaJS hingga pengaturan langsung, langkah-langkah instalasi di berbagai platform, dan contoh kode praktis. Tutorial ini akan membantu Anda mengintegrasikan elysiajs dengan openapi secara mulus, memanfaatkan kecepatan Bun untuk pengalaman pengembangan yang optimal.

Apa itu ElysiaJS?

ElysiaJS adalah kerangka kerja web Node.js yang ringan dan cepat, dirancang untuk minimalis namun sangat dapat diperluas untuk membangun API RESTful. Ini menekankan area permukaan yang kecil, dukungan TypeScript yang bersih, dan API yang intuitif untuk mendefinisikan rute, middleware, dan plugin. ElysiaJS bertujuan untuk memberikan kinerja dengan pengalaman yang ramah pengembang dan integrasi OpenAPI yang kuat secara langsung. Kekuatan intinya meliputi dukungan OpenAPI kelas satu, ekosistem plugin, dan desain yang mengutamakan kecepatan dan kesederhanaan tanpa mengunci Anda pada abstraksi yang berat. Ini membuat ElysiaJS sangat menarik bagi pengembang yang ingin fokus pada logika daripada boilerplate, sambil memastikan API mereka mudah didokumentasikan dan dikonsumsi melalui spesifikasi OpenAPI.

Mengapa Memilih ElysiaJS pada Tahun 2026?

Memilih ElysiaJS membawa beberapa manfaat menarik yang meningkatkan proses pengembangan API Anda.

1. Kinerja menonjol dengan runtime yang ramping dan fokus pada penanganan rute yang cepat serta overhead yang rendah, memungkinkan aplikasi untuk berskala efisien di bawah beban. Kesiapan OpenAPI bawaan berarti Anda dapat menghasilkan dan menyajikan spesifikasi OpenAPI dengan mudah, yang menyederhanakan dokumentasi API dan pembuatan klien—penting bagi tim yang berkolaborasi dalam microservice atau API publik.
2. Pengalaman pengembang adalah sorotan lain: ElysiaJS ramah TypeScript, dengan definisi rute yang ringkas dan arsitektur modular yang mendukung pertumbuhan seiring dengan perluasan proyek Anda. Ekosistemnya mencakup serangkaian plugin yang berkembang untuk dukungan OpenAPI, dokumentasi, dan utilitas pengujian, berintegrasi dengan mulus dengan alat yang ada. Desain yang mengutamakan OpenAPI memastikan konsistensi antara kode dan dokumen Anda, mengurangi upaya pemeliharaan.

Apa itu Bun?

Bun adalah runtime JavaScript yang cepat, manajer paket, dan bundler dalam satu kesatuan. Ini dirancang untuk menjadi pengganti langsung (drop-in replacement) untuk Node.js dalam banyak kasus, menawarkan waktu startup yang lebih cepat dan perkakas yang efisien. Bun dapat mempercepat alur kerja pengembangan, instalasi dependensi, dan eksekusi skrip, menjadikannya pasangan populer dengan kerangka kerja modern seperti ElysiaJS. Dengan menangani berbagai peran dalam ekosistem JavaScript, Bun mengurangi pergantian konteks, memungkinkan pengembang untuk fokus pada pembangunan daripada mengelola alat. Kompatibilitasnya dengan API Node memastikan transisi yang mulus, sementara dukungan TypeScript dan JSX asli meningkatkan produktivitas dalam proyek ElysiaJS.

Menginstal Bun (MacOS, Linux, dan Windows)

Memasang dan menjalankan Bun sangat mudah di berbagai platform, memastikan Anda dapat memasangkannya dengan ElysiaJS dengan cepat.

1. Untuk MacOS, buka Terminal dan jalankan skrip instalasi: curl -fsSL https://bun.sh/install | bash. Ini mengunduh dan menyiapkan Bun, menambahkannya ke PATH Anda. Verifikasi dengan bun --version.
2. Di Linux, gunakan perintah curl yang sama di terminal Anda: curl -fsSL https://bun.sh/install | bash. Ini mendukung distribusi utama seperti Ubuntu dan Fedora. Mulai ulang shell Anda atau sumber profil Anda, lalu periksa bun --version untuk mengonfirmasi.
3. Pengguna Windows dapat menginstal melalui PowerShell sebagai administrator: powershell -c "irm bun.sh/install.ps1 | iex". Ini menangani pengaturan, termasuk integrasi Chocolatey jika diperlukan. Luncurkan PowerShell lagi dan jalankan bun --version untuk memverifikasi.

Dalam semua kasus, Bun terinstal dalam hitungan detik dan siap untuk proyek ElysiaJS—tidak ada konfigurasi tambahan yang diperlukan untuk penggunaan dasar.

Memulai dengan ElysiaJS

Memulai proyek ElysiaJS diawali dengan beberapa prasyarat:

• Lingkungan Node.js atau Bun terinstal (Jika memilih perkakas Bun yang lebih cepat, unduh dari bun.sh seperti yang dijelaskan sebelumnya).
• Direktori proyek.

Untuk menginisialisasi, gunakan Bun untuk kecepatan: bun create elysia my-api. Ini akan membuat struktur dasar dengan package.json dan dukungan TypeScript.

Tanpa Bun, jalankan npm create elysia my-api melalui npm. Navigasi ke dalam folder dengan cd my-api, dan Anda siap untuk mendefinisikan rute.

Pengaturan minimal ElysiaJS mendorong pembuatan prototipe yang cepat—impor modul inti, definisikan handler, dan dengarkan pada port. Fondasi ini berskala dengan mudah, mengintegrasikan OpenAPI untuk dokumentasi sejak awal.

Menginstal dan Mengatur ElysiaJS

Instalasi adalah satu baris perintah setelah runtime Anda siap. Dengan Bun: bun install elysia.

Untuk npm: npm install elysia. Jika menggunakan TypeScript, tambahkan @types/node untuk kelengkapan.

Pengaturan melibatkan pembuatan file entri, index.ts:

import { Elysia } from "elysia";

const app = new Elysia().get("/", () => "Hello Elysia").listen(3000);

console.log(
  `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`
);

Jalankan dengan Bun: bun run index.ts, atau Node: npx ts-node index.ts. Kunjungi "http://localhost:3000" untuk melihat responsnya. Aplikasi dasar ini mengkonfirmasi kesederhanaan ElysiaJS—perluas dengan middleware atau plugin sesuai kebutuhan.

Mengintegrasikan ElysiaJS dengan OpenAPI

Dukungan OpenAPI ElysiaJS bersinar melalui plugin, memungkinkan spesifikasi yang dihasilkan secara otomatis dari rute Anda. Instal plugin: bun add @elysiajs/openapi (atau yang setara dengan npm).

Konfigurasi di aplikasi Anda:

import { Elysia } from 'elysia'
import { openapi, fromTypes } from '@elysiajs/openapi'

export const app = new Elysia()
    .use(
        openapi({
            references: fromTypes() 
        })
    )
    .get(
        '/pets',
        () => [
            { id: 1, name: 'Fluffy' },
            { id: 2, name: 'Spot' }
        ],
        ({
            summary: 'Get all pets',
            responses: { 200: { description: 'Success' } }
        } as any)
    )
    .listen(3000)

Akses dokumen di "/openapi" atau "/docs" (yaitu "http://localhost:3000/openapi"), tempat Swagger UI merender skema interaktif. ElysiaJS menyimpulkan tipe dari handler, memperketat keselarasan kode-spesifikasi. Untuk pengaturan lanjutan, hasilkan dari TypeScript menggunakan alat ekosistem, memastikan elysiajs dengan openapi berkembang seiring dengan basis kode Anda.

Klik "Test Request" untuk menguji contoh endpoint API "Pets" yang baru saja kita buat.

Contoh Kode: Membangun dan Menguji Aplikasi ElysiaJS Dasar

Pengujian ElysiaJS dimulai dengan aplikasi sederhana. Kembangkan "hello world":

import { Elysia } from 'elysia'

const app = new Elysia()
  .get('/', () => 'Hello from ElysiaJS!')
  .post('/echo', ({ body }) => body, {
    body: t.Object({ message: t.String() })
  })
  .listen(3000, () => console.log('Server listening on http://localhost:3000'))

Jalankan dan uji dengan curl: curl -X POST http://localhost:3000/echo -H "Content-Type: application/json" -d "{\"message\": \"Test\"}". Harapkan respons yang digemakan.

Untuk pengujian unit, gunakan bun:test. Buat folder "test" di direktori root proyek Anda dan tambahkan file index.test.ts dengan kode berikut:

import { describe, expect, it } from 'bun:test'
import { Elysia } from 'elysia'

describe('Elysia', () => {
    it('returns a response', async () => {
        const app = new Elysia().get('/', () => 'hi')

        const response = await app
            .handle(new Request('http://localhost/'))
            .then((res) => res.text())

        expect(response).toBe('hi')
    })
})

Untuk menjalankan tes, cukup gunakan perintah: bun test.

Ini memvalidasi fungsionalitas inti, mengkonfirmasi keandalan ElysiaJS.

Contoh Kode: ElysiaJS dengan OpenAPI dalam Aksi

Untuk elysiajs dengan openapi, bangun API hewan peliharaan:

import { Elysia, t } from 'elysia'
import { openapi, fromTypes } from '@elysiajs/openapi'

const app = new Elysia()
  .use(
    openapi({
      references: fromTypes() 
    })
  )
  .get('/pets', () => [
    { id: 1, name: 'Fluffy', type: 'Cat' },
    { id: 2, name: 'Spot' }
  ], ({
    summary: 'List pets',
    responses: {
      200: {
        description: 'Success',
        content: {
          'application/json': {
            schema: {
              type: 'array',
              items: { type: 'object', properties: { id: { type: 'integer' }, name: { type: 'string' }, type: { type: 'string' } } }
            }
          }
        }
      }
    }
  } as any))
  .post('/pets', ({ body }) => ({ id: Date.now(), ...body }), {
    body: t.Object({ name: t.String(), type: t.String() }),
    summary: 'Create pet',
    responses: { 200: { description: 'Created' } }
  })
  .listen(3000, () => console.log('Server listening on http://localhost:3000'))
import { Elysia, t } from 'elysia'
import { openapi, fromTypes } from '@elysiajs/openapi'

const app = new Elysia()
  .use(
    openapi({
      references: fromTypes() 
    })
  )
  .get('/pets', () => [
    { id: 1, name: 'Fluffy', type: 'Cat' },
    { id: 2, name: 'Spot' }
  ], ({
    summary: 'List pets',
    responses: {
      200: {
        description: 'Success',
        content: {
          'application/json': {
            schema: {
              type: 'array',
              items: { type: 'object', properties: { id: { type: 'integer' }, name: { type: 'string' }, type: { type: 'string' } } }
            }
          }
        }
      }
    }
  } as any))
  .post('/pets', ({ body }) => ({ id: Date.now(), ...body }), {
    body: t.Object({ name: t.String(), type: t.String() }),
    summary: 'Create pet',
    responses: { 200: { description: 'Created' } }
  })
  .listen(3000, () => console.log('Server listening on http://localhost:3000'))

Uji POST: curl -X POST http://localhost:3000/pets -H "Content-Type: application/json" -d '{"name": "Scooby Doo", "type": "Dog"}'. Kunjungi /openapi untuk dokumen Swagger, memverifikasi skema dan jalur.

Tips Praktis untuk Kesiapan Produksi

Keamanan tipe (type safety) sangat penting: Manfaatkan tipe TypeScript untuk badan permintaan (request bodies), respons, dan parameter rute untuk meningkatkan keandalan dan akurasi generasi OpenAPI. Observabilitas memerlukan penambahan logging, metrik, dan middleware penanganan kesalahan untuk memantau perilaku API. Langkah-langkah keamanan meliputi implementasi kontrol CORS, validasi input, pembatasan laju (rate limiting), dan otentikasi sesuai kebutuhan. Pengemasan melibatkan penggunaan langkah-langkah build produksi Bun atau bundler Anda untuk menghasilkan paket deployment yang ramping. Dokumentasi memerlukan penjagaan spesifikasi OpenAPI agar tetap sinkron dengan kode untuk memastikan SDK klien dan dokumentasi tetap mutakhir.

Pertanyaan yang Sering Diajukan

Q1: Apakah ElysiaJS cocok untuk aplikasi skala besar?
Jawab: Ya, desain modular dan fokus pada kinerja membuatnya dapat diskalakan untuk API perusahaan.

Q2: Apakah ElysiaJS memerlukan TypeScript?
Jawab: Tidak, tetapi sangat direkomendasikan untuk generasi OpenAPI yang aman tipe.

Q3: Bagaimana perbandingan Bun dengan Node.js dengan ElysiaJS?
Jawab: Bun menawarkan instalasi dan eksekusi yang lebih cepat, tetapi Node.js berfungsi jika Anda lebih memilih keakraban.

Q4: Bisakah saya menghasilkan spesifikasi OpenAPI dari kode yang sudah ada?
Jawab: Tentu saja, menggunakan plugin ElysiaJS yang menyimpulkan dari definisi rute.

Q5: Kerangka kerja pengujian apa yang paling cocok dengan ElysiaJS?
Jawab: Apidog, Vitest atau Jest untuk pengujian unit, dengan Supertest untuk simulasi API.

Kesimpulan: Bangun API yang Lebih Cerdas dengan ElysiaJS, OpenAPI, dan Bun

ElysiaJS, dengan perpaduan kecepatan dan kesederhanaannya, dipasangkan dengan efisiensi runtime Bun dan kekuatan dokumentasi OpenAPI, membentuk tumpukan yang menarik untuk pengembangan API. Dari instalasi hingga pengujian, panduan ini telah membekali Anda untuk mulai membangun. Bereksperimenlah dengan contoh-contohnya, perbaiki rute Anda, dan saksikan proyek Anda berkembang—ElysiaJS siap untuk menggerakkan kreasi Anda berikutnya.