bun-elysia

Bun + Elysia.js Development

Build high-performance full-stack applications with Bun runtime and Elysia.js framework.

Quick Start

New Elysia Project

bun create elysia my-app
cd my-app
bun run dev

Basic Server

import { Elysia, t } from "elysia";

const app = new Elysia()
  .get("/", () => "Hello, World!")
  .get("/users/:id", ({ params }) => ({ id: params.id }), {
    params: t.Object({ id: t.Number() })
  })
  .post("/users", ({ body }) => ({ created: body }), {
    body: t.Object({
      name: t.String(),
      email: t.String({ format: "email" })
    })
  })
  .listen(3000);

With Bun Native APIs

import { Elysia } from "elysia";
import { sql } from "bun";
import { redis } from "bun";

const app = new Elysia()
  .decorate("sql", sql)
  .decorate("redis", redis)
  .get("/users", async ({ sql }) => {
    return sql`SELECT * FROM users`;
  })
  .get("/cache/:key", async ({ redis, params }) => {
    return redis.get(params.key);
  })
  .listen(3000);

---

Reference Navigation

What do you want to do?

Set up a project:

• Monorepo with workspaces → monorepo.md

Use Bun native APIs:

• PostgreSQL/MySQL/SQLite → native-apis/sql.md
• Redis/Valkey → native-apis/redis.md
• S3/Object storage → native-apis/s3.md
• HTTP server basics → native-apis/http-server.md

Build with Elysia:

• Routing and handlers → elysia/core.md
• Request/response validation → elysia/validation.md
• Hooks, middleware, plugins → elysia/lifecycle.md
• WebSocket support → elysia/websocket.md
• OpenAPI/Swagger docs → elysia/swagger.md
• Type-safe client (Eden) → elysia/eden.md

Migrate from Fastify:

• Routing, params, body → migration/fastify-basics.md
• Schema validation → migration/fastify-validation.md
• Lifecycle hooks → migration/fastify-hooks.md
• Plugin architecture → migration/fastify-plugins.md
• Authentication → migration/fastify-auth.md
• WebSocket, Swagger, files → migration/fastify-advanced.md

---

Common Patterns

Authentication Middleware

import { Elysia } from "elysia";
import { jwt } from "@elysiajs/jwt";

const app = new Elysia()
  .use(jwt({ secret: process.env.JWT_SECRET! }))
  .derive(async ({ headers, jwt }) => {
    const token = headers.authorization?.replace("Bearer ", "");
    const user = token ? await jwt.verify(token) : null;
    return { user };
  })
  .get("/profile", ({ user, error }) => {
    if (!user) return error(401);
    return user;
  });

Database with Validation

import { Elysia, t } from "elysia";
import { sql } from "bun";

const app = new Elysia()
  .post("/users", async ({ body }) => {
    const [user] = await sql`
      INSERT INTO users (name, email)
      VALUES (${body.name}, ${body.email})
      RETURNING *
    `;
    return user;
  }, {
    body: t.Object({
      name: t.String({ minLength: 1 }),
      email: t.String({ format: "email" })
    })
  });

Grouped Routes with Guard

app.group("/api", (app) =>
  app
    .guard({
      headers: t.Object({
        authorization: t.String()
      }),
      beforeHandle: ({ headers, error }) => {
        if (!isValidToken(headers.authorization)) {
          return error(401);
        }
      }
    }, (app) =>
      app
        .get("/users", getUsers)
        .post("/users", createUser)
    )
);

WebSocket Chat

app.ws("/chat", {
  body: t.Object({
    room: t.String(),
    message: t.String()
  }),
  open(ws) {
    ws.subscribe("general");
  },
  message(ws, { room, message }) {
    ws.publish(room, { from: ws.id, message });
  }
});

---

Key Differences: Fastify vs Elysia

Fastify	Elysia
request.params	{ params }
request.query	{ query }
request.body	{ body }
reply.code(n).send(x)	set.status = n; return x
reply.header(k, v)	set.headers[k] = v
JSON Schema	TypeBox (t.*)
preHandler hook	beforeHandle
fastify.decorate()	.decorate()
fastify.register(plugin)	.use(plugin)

---

Installation

# Elysia and plugins
bun add elysia @elysiajs/swagger @elysiajs/jwt @elysiajs/cors @elysiajs/static @elysiajs/eden

# Types
bun add -d @types/bun typescript