Context#

// Classic style
app.get("/users/:id", (ctx) => {
  const { id } = ctx.params; // string
  return ctx.json({ userId: id });
});

// Elysia-style destructuring + flexible return
app.get("/users/:id", ({ params }) => params); // { id: "123" } as JSON
app.get("/users/:id", ({ params: { id } }) => id); // "123" as text/plain

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

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

// GET /search?q=buntok&page=1&limit=10

app.get("/ip", (ctx) => {
  return ctx.json({ ip: ctx.ip });
});

// Use ctx.store to share data between middleware
const auth = async (ctx, next) => {
  ctx.store.user = await verifyToken(ctx);
  return next();
};

app.get("/profile", auth, (ctx) => {
  return ctx.json({ user: ctx.store.user });
});

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

// FormData (file uploads)
app.post("/upload", async (ctx) => {
  const form = await ctx.formData();
  const file = form.get("avatar");
  return ctx.json({ uploaded: true });
});

app.get("/profile", (ctx) => {
  const token = ctx.getCookie("token");
  const all = ctx.getCookies();
  return ctx.json({ token, cookies: all });
});

import { zValidator, z } from "@buntok/core/middlewares/validator";

const userSchema = z.object({
  name: z.string().min(1),
  email: z.string().email(),
});

app.post("/users", zValidator("body", userSchema), (ctx) => {
  const data = ctx.valid("body"); // typed as { name: string; email: string }
  return ctx.json({ created: true, ...data });
});

app.get("/search", zValidator("query", searchSchema), (ctx) => {
  const { q } = ctx.valid("query"); // typed from schema
  return ctx.json({ results: [] });
});

// All of these are valid handlers
app.get("/hello", () => "hello world");                    // text/plain
app.get("/json", () => ({ hello: "buntok" }));             // json
app.get("/num", () => 42);                                 // text/plain "42"
app.get("/users", () => [{ id: 1 }, { id: 2 }]);           // json array
app.get("/empty", () => null);                             // 204
app.get("/custom", () => new Response("hi", { status: 201 })); // passthrough

// Destructuring (ctx is an instance with params/query/store/ip/...)
app.get("/users/:id", ({ params }) => params);               // { id: "123" }
app.get("/users/:id", ({ params: { id } }) => id);          // "123"
app.get("/search", ({ query }) => query.q);                  // ?q=...
app.get("/profile", ({ store, request }) => store.user);

// Default 200
return ctx.json({ message: "Hello" });

// Custom status
return ctx.json({ created: true }, 201);

// { success: true, message: "Success", data: [...] }
return ctx.success(users);

// { success: true, message: "Created", data: {...} }, 201
return ctx.success(user, "Created", 201);

// Offset-based pagination
app.get("/users", async (ctx) => {
  const page = Number(ctx.query.page) || 1;
  const limit = Number(ctx.query.limit) || 10;
  const users = await db.user.findMany({ skip: (page - 1) * limit, take: limit });
  const total = await db.user.count();
  return ctx.paginate(users, total, page, limit);
});

// Response:
// {
//   success: true,
//   message: "Success",
//   data: [...],
//   meta: {
//     currentPage: 1,
//     perPage: 10,
//     total: 50,
//     lastPage: 5,
//     hasMore: true
//   }
// }

// Cursor-based pagination
return ctx.cursorPaginate(users, nextCursor);

// { success: false, message: "Validation failed", details: [...] }
return ctx.error("Validation failed", 422, errors);

// 302 redirect (default)
return ctx.redirect("/login");

// 301 permanent redirect
return ctx.redirect("/new-url", 301);

app.get("/api", (ctx) => {
  ctx.onAfterResponse((res) => {
    console.log("Response status:", res.status);
    // Return modified response, or undefined to keep original
    return res;
  });

  return ctx.json({ data: "hello" });
});

app.get("/custom-headers", (ctx) => {
  ctx.set.headers["x-powered-by"] = "benchmark";
  ctx.set.headers["x-a"] = 1; // number → "1"
  ctx.set.headers["set-cookie"] = ["a=1; Path=/", "b=2; Path=/"];
  return "ok";
});

app.get("/events", (ctx) => {
  return ctx.sse((stream) => {
    stream.sendData("connected");
    stream.sendEvent("update", { count: 42 });
    stream.onClose(() => {
      console.log("Client disconnected");
    });
  });
});

app.get("/info", (ctx) => {
  // Headers
  const contentType = ctx.request.headers.get("Content-Type");
  const auth = ctx.request.headers.get("Authorization");

  // Method
  const method = ctx.request.method;

  // URL
  const url = ctx.request.url;

  return ctx.json({ method, url, contentType });
});

// Context<DI, Params>
// DI: type of the dependency injection container
// Params: type of route parameters (inferred from path)

app.get("/users/:id", (ctx) => {
  // ctx.params.id is typed as string
  // ctx.di is typed based on your DI setup
});

import { z } from "@buntok/core/middlewares/validator";

const app = new Buntok();

app.get("/", (ctx) => {
  return ctx.json({
    ip: ctx.ip,
    method: ctx.request.method,
    url: ctx.request.url,
  });
});

app.get("/search", zValidator("query", z.object({
  q: z.string(),
  page: z.coerce.number().default(1),
})), (ctx) => {
  const { q, page } = ctx.valid("query");
  return ctx.json({ query: q, page });
});

app.post("/users", zValidator("body", z.object({
  name: z.string().min(1),
  email: z.string().email(),
})), async (ctx) => {
  const data = ctx.valid("body");
  return ctx.success(data, "Created", 201);
});

app.get("/dashboard", (ctx) => {
  const token = ctx.getCookie("token");
  if (!token) return ctx.redirect("/login");
  return ctx.json({ user: ctx.user });
});

app.listen(1212);