Bun dan Elysia.js: High Performance API

# macOS / Linux / WSL
curl -fsSL https://bun.sh/install | bash

# Windows (PowerShell)
powershell -c "irm bun.sh/install.ps1 | iex"

# Via npm (jika sudah punya Node.js)
npm install -g bun

# Verifikasi
bun --version
# 1.1.x

# Bun sebagai package manager (drop-in replacement npm)
bun install              # Menggantikan npm install (20x lebih cepat)
bun add express          # Menggantikan npm install express
bun add -d typescript    # Menggantikan npm install -D typescript

# Bun sebagai test runner
bun test                 # Menggantikan jest/mocha

# Membuat project baru dengan template Elysia
bun create elysia my-api
cd my-api

# Atau manual:
mkdir my-api && cd my-api
bun init -y
bun add elysia @elysiajs/cors @elysiajs/swagger

# Jalankan development server
bun run src/index.ts
# Server berjalan di http://localhost:3000

# File: package.json
# {
#   "name": "my-api",
#   "scripts": {
#     "dev": "bun run --watch src/index.ts",
#     "start": "bun run src/index.ts"
#   }
# }

// src/index.ts
import { Elysia } from "elysia";

const app = new Elysia()
  .get("/", () => "Hello, Elysia! 🦊")
  .get("/json", () => ({
    message: "Ini JSON response",
    timestamp: Date.now(),
  }))
  .listen(3000);

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

// src/index.ts
import { Elysia } from "elysia";
import { cors } from "@elysiajs/cors";
import { swagger } from "@elysiajs/swagger";

const app = new Elysia()
  .use(cors())                    // CORS middleware
  .use(swagger())                // Swagger docs di /swagger
  .get("/", () => "Hello World")
  .get("/health", () => ({
    status: "ok",
    uptime: process.uptime(),
    memory: process.memoryUsage(),
  }))
  .listen(3000);

export type App = typeof app;    // Export type untuk client

// src/routes/users.ts
import { Elysia, t } from "elysia";

// Simulasi database
const users = [
  { id: 1, name: "Budi", email: "budi@mail.com" },
  { id: 2, name: "Ani", email: "ani@mail.com" },
];

export const userRoutes = new Elysia({ prefix: "/api/users" })

  // GET /api/users — Ambil semua user
  .get("/", () => users)

  // GET /api/users/:id — Ambil user by ID
  .get("/:id", ({ params: { id } }) => {
    const user = users.find((u) => u.id === Number(id));
    if (!user) {
      return new Response(JSON.stringify({ error: "User tidak ditemukan" }), {
        status: 404,
      });
    }
    return user;
  })

  // POST /api/users — Buat user baru
  .post(
    "/",
    ({ body }) => {
      const newUser = { id: users.length + 1, ...body };
      users.push(newUser);
      return { success: true, user: newUser };
    },
    {
      body: t.Object({
        name: t.String({ minLength: 2 }),
        email: t.String({ format: "email" }),
      }),
    }
  )

  // PUT /api/users/:id — Update user
  .put(
    "/:id",
    ({ params: { id }, body }) => {
      const index = users.findIndex((u) => u.id === Number(id));
      if (index === -1) {
        return new Response(JSON.stringify({ error: "User tidak ditemukan" }), {
          status: 404,
        });
      }
      users[index] = { ...users[index], ...body };
      return { success: true, user: users[index] };
    },
    {
      body: t.Object({
        name: t.Optional(t.String()),
        email: t.Optional(t.String({ format: "email" })),
      }),
    }
  )

  // DELETE /api/users/:id — Hapus user
  .delete("/:id", ({ params: { id } }) => {
    const index = users.findIndex((u) => u.id === Number(id));
    if (index === -1) {
      return new Response(JSON.stringify({ error: "User tidak ditemukan" }), {
        status: 404,
      });
    }
    users.splice(index, 1);
    return { success: true, message: "User dihapus" };
  });

// src/index.ts — Menggabungkan routes
import { Elysia } from "elysia";
import { userRoutes } from "./routes/users";
import { postRoutes } from "./routes/posts";

const app = new Elysia()
  .use(userRoutes)
  .use(postRoutes)

  // Query parameters
  .get("/search", ({ query }) => {
    const { q, page = "1", limit = "10" } = query;
    return {
      query: q,
      page: Number(page),
      limit: Number(limit),
      results: [], // Hasil pencarian
    };
  })

  // Pattern matching wildcard
  .get("/files/*", ({ params }) => {
    return { path: params["*"] };
  })

  .listen(3000);

import { Elysia } from "elysia";

const app = new Elysia()

  // onRequest — dijalankan untuk setiap request
  .onRequest(({ request }) => {
    console.log(`→ ${request.method} ${new URL(request.url).pathname}`);
  })

  // onBeforeHandle — sebelum handler dipanggil
  .onBeforeHandle(({ request, set }) => {
    // Auth middleware
    const token = request.headers.get("Authorization");
    if (new URL(request.url).pathname.startsWith("/api/protected")) {
      if (!token || !token.startsWith("Bearer ")) {
        set.status = 401;
        return { error: "Unauthorized" };
      }
    }
  })

  // onAfterHandle — setelah handler mengembalikan response
  .onAfterHandle(({ response, set }) => {
    // Tambahkan custom headers
    set.headers["X-Powered-By"] = "Elysia";
    set.headers["X-Response-Time"] = `${Date.now()}ms`;
    return response;
  })

  // onError — menangani error
  .onError(({ error, code, set }) => {
    console.error(`Error [${code}]:`, error.message);

    switch (code) {
      case "NOT_FOUND":
        set.status = 404;
        return { error: "Endpoint tidak ditemukan" };
      case "VALIDATION":
        set.status = 422;
        return { error: "Validasi gagal", details: error.message };
      case "INTERNAL_SERVER_ERROR":
        set.status = 500;
        return { error: "Server error internal" };
    }
  })

  .get("/", () => "Hello World")
  .get("/api/protected/data", () => ({ secret: "data rahasia" }))
  .listen(3000);

// src/plugins/auth.ts
import { Elysia } from "elysia";

interface AuthConfig {
  secret: string;
  exclude?: string[];
}

export const authPlugin = (config: AuthConfig) =>
  new Elysia({ name: "auth" })
    .derive(({ request }) => {
      const token = request.headers.get("Authorization")?.replace("Bearer ", "");
      return {
        user: token ? verifyToken(token, config.secret) : null,
      };
    })
    .onBeforeHandle(({ request, set, user }) => {
      const path = new URL(request.url).pathname;

      // Skip auth untuk excluded paths
      if (config.exclude?.some((p) => path.startsWith(p))) return;

      if (!user) {
        set.status = 401;
        return { error: "Silakan login terlebih dahulu" };
      }
    });

// Penggunaan
const app = new Elysia()
  .use(
    authPlugin({
      secret: process.env.JWT_SECRET ?? "my-secret",
      exclude: ["/api/public", "/health"],
    })
  )
  .get("/api/profile", ({ user }) => user)
  .listen(3000);

function verifyToken(token: string, secret: string) {
  // Verifikasi JWT (contoh sederhana)
  return { id: "1", name: "Budi", email: "budi@mail.com" };
}

// src/index.ts — Server
import { Elysia, t } from "elysia";

const app = new Elysia()
  .get("/api/users", () => [
    { id: 1, name: "Budi", email: "budi@mail.com" },
    { id: 2, name: "Ani", email: "ani@mail.com" },
  ])
  .post(
    "/api/users",
    ({ body }) => ({
      success: true,
      user: { id: 3, ...body },
    }),
    {
      body: t.Object({
        name: t.String(),
        email: t.String({ format: "email" }),
      }),
    }
  )
  .listen(3000);

// Export type Elysia
export type App = typeof app;

// client.ts — Client code
import { treaty } from "@elysiajs/eden";
import type { App } from "./src/index";

// Buat client dengan type safety penuh
const api = treaty<App>("localhost:3000");

// GET /api/users — TypeScript tahu return type-nya!
const { data: users, error } = await api.api.users.get();
if (users) {
  users.forEach((user) => {
    // TypeScript tahu: user.name (string), user.email (string)
    console.log(`${user.name} (${user.email})`);
  });
}

// POST /api/users — Type-safe body!
const { data: result } = await api.api.users.post({
  name: "Sari",
  email: "sari@mail.com",
});
// TypeScript tahu: result.success (boolean), result.user (object)

// Autocomplete berfungsi sempurna:
// api. → menunjukkan semua endpoint yang tersedia
// api.api.users.post({ → menunjukkan field yang dibutuhkan

import { Elysia, t } from "elysia";

const app = new Elysia()
  // Validasi body, params, dan query sekaligus
  .post(
    "/api/orders",
    ({ body, query }) => {
      // body dan query sudah ter-validasi dan ter-typed
      return {
        orderId: Math.random().toString(36).slice(2),
        items: body.items,
        page: query.page,
      };
    },
    {
      // Validasi request body
      body: t.Object({
        customerName: t.String({ minLength: 2, maxLength: 100 }),
        email: t.String({ format: "email" }),
        items: t.Array(
          t.Object({
            productId: t.String(),
            quantity: t.Number({ minimum: 1, maximum: 999 }),
            price: t.Number({ minimum: 0 }),
          }),
          { minItems: 1, maxItems: 50 }
        ),
        shippingAddress: t.Object({
          street: t.String(),
          city: t.String(),
          province: t.String(),
          postalCode: t.String({ pattern: "^[0-9]{5}$" }),
        }),
        paymentMethod: t.Union([
          t.Literal("credit_card"),
          t.Literal("bank_transfer"),
          t.Literal("ewallet"),
        ]),
        notes: t.Optional(t.String({ maxLength: 500 })),
      }),

      // Validasi query parameters
      query: t.Object({
        page: t.Optional(t.Numeric({ minimum: 1 })),
        sort: t.Optional(
          t.Union([t.Literal("newest"), t.Literal("cheapest")])
        ),
      }),

      // Validasi response (documentation)
      response: {
        200: t.Object({
          orderId: t.String(),
          items: t.Array(t.Any()),
          page: t.Number(),
        }),
        422: t.Object({
          error: t.String(),
          details: t.Any(),
        }),
      },
    }
  )
  .listen(3000);

# Install benchmarking tool (wrk)
# macOS: brew install wrk
# Linux: sudo apt install wrk

# Benchmark Elysia
wrk -t12 -c400 -d30s http://localhost:3000/

# Benchmark dengan autocannon (Node.js)
npx autocannon -c 100 -d 30 http://localhost:3000/

# Hasil contoh:
# Running 30s test @ http://localhost:3000/
# 12 threads and 400 connections
# Thread Stats   Avg      Stdev     Max   +/- Stdev
# Latency       0.03ms    0.01ms   0.50ms   95.00%
# Req/Sec    23,333    1,200.00  25,000    80.00%
# 840,000 requests in 30.00s