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
```typescript
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

bun-elysia

Bun + Elysia.js Development

Quick Start

New Elysia Project

Basic Server