Routing#

import { Buntok } from "@buntok/core";

const app = new Buntok();

// Classic style
app.get("/", (ctx) => {
  return ctx.json({ message: "Hello, World!" });
});

// Elysia-style flexible return (also supported)
app.get("/hello", () => "hello world");                    // text/plain
app.get("/json", () => ({ hello: "buntok" }));             // application/json
app.get("/users/:id", ({ params }) => params);               // { id: "123" }

// Static value handlers - response baked at registration, served natively
app.get("/ping", "pong");                                   // text/plain
app.get("/version", new Response("v2", { status: 200 }));   // Response passthrough

app.post("/users", async (ctx) => {
  const body = await ctx.body();
  return ctx.json({ created: true, ...body }, 201);
});

app.put("/users/:id", (ctx) => {
  return ctx.json({ updated: true });
});

app.delete("/users/:id", (ctx) => {
  return ctx.json({ deleted: true });
});

app.listen(1212);

app.all("/health", (ctx) => {
  return ctx.json({ status: "ok" });
});

// Single parameter - classic
app.get("/users/:id", (ctx) => {
  const { id } = ctx.params;
  return ctx.json({ userId: id });
});

// Single parameter - Elysia-style
app.get("/users/:id", ({ params }) => params);               // { id: "123" }
app.get("/users/:id", ({ params: { id } }) => id);          // "123" text/plain

// Multiple parameters
app.get("/posts/:postId/comments/:commentId", (ctx) => {
  const { postId, commentId } = ctx.params;
  return ctx.json({ postId, commentId });
});
app.get("/posts/:postId/comments/:commentId", ({ params }) => params);

app.get("/users/:id", (ctx) => {
  // ctx.params is typed as { id: string }
  const { id } = ctx.params; // ✅ Type-safe
  const { name } = ctx.params; // ❌ Type error: 'name' does not exist
});

app.get("/files/*", (ctx) => {
  const path = ctx.params["*"];
  return ctx.json({ filePath: path });
});
app.get("/files/*", ({ params }) => params["*"]); // shorthand

// GET /files/documents/report.pdf
// Response: { "filePath": "documents/report.pdf" }

app.get("/search", (ctx) => {
  const { q, page, limit } = ctx.query;
  return ctx.json({ query: q, page, limit });
});
app.get("/search", ({ query }) => query); // shorthand

// GET /search?q=buntok&page=1&limit=10
// Response: { "query": "buntok", "page": "1", "limit": "10" }

const api = app.group("/api");

api.get("/users", listUsers);
api.post("/users", createUser);
api.get("/users/:id", getUser);

// Registered routes:
// GET  /api/users
// POST /api/users
// GET  /api/users/:id

const api = app.group("/api");
const v1 = api.group("/v1");
const v2 = api.group("/v2");

v1.get("/users", listUsersV1);
v2.get("/users", listUsersV2);

// Registered routes:
// GET /api/v1/users
// GET /api/v2/users

const api = app.group("/api");
api.use(cors);
api.use(rateLimit);

api.get("/users", listUsers);
api.post("/users", createUser);

// Execution order for GET /api/users:
// cors → rateLimit → listUsers

const auth = async (ctx, next) => {
  const token = ctx.getCookie("token");
  if (!token) return ctx.json({ error: "Unauthorized" }, 401);
  // verify token...
  return next();
};

app.get("/admin", auth, (ctx) => {
  return ctx.json({ secret: "data" });
});

// Multiple middleware
app.get("/admin/settings", auth, checkRole("admin"), (ctx) => {
  return ctx.json({ settings: {} });
});

// Runs for every request
app.use(logger);
app.cors({ origin: "*" });  // Use app.cors() for CORS

// Execution order:
// logger → cors → route-level middleware → handler

// Serve files from ./public at /public/*
app.static("/public", "./public");

// Serve files from ./assets at /files/*
app.static("/files", "./assets");

app.ws("/chat", {
  open: (ws) => {
    ws.send(JSON.stringify({ type: "connected" }));
  },
  message: (ws, message) => {
    // Broadcast to all connected clients
    ws.publish("chat", message);
  },
  close: (ws, code, reason) => {
    console.log("Client disconnected:", code);
  },
});

// Custom error handler
app.onError((err, ctx) => {
  console.error(err);
  return ctx.json(
    { success: false, error: err.message },
    500
  );
});

// Custom 404 handler
app.notFound((ctx) => {
  return ctx.json(
    { success: false, error: "Not Found", path: ctx.request.url },
    404
  );
});

import { NotFoundError, ForbiddenError } from "@buntok/core";

app.get("/users/:id", async (ctx) => {
  const user = await findUser(ctx.params.id);
  if (!user) throw new NotFoundError("User not found");
  if (!canView(user, ctx.user)) throw new ForbiddenError();
  return ctx.json(user);
});