@bunary/http 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+All notable changes to `@bunary/http` will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.0.1] - 2025-01-27
+
+### Added
+
+- Initial release of `@bunary/http`
+- `createApp()` factory function for creating Bunary applications
+- HTTP method helpers: `get()`, `post()`, `put()`, `delete()`, `patch()`
+- Path parameter extraction (`:param` syntax)
+- Query parameter parsing via `ctx.query`
+- Automatic JSON serialization for objects and arrays
+- String responses returned as `text/plain`
+- `null`/`undefined` returns converted to 204 No Content
+- Response objects passed through unchanged
+- `404 Not Found` for unregistered routes
+- `405 Method Not Allowed` for wrong HTTP methods
+- Error handling with 500 responses for uncaught exceptions
+- `listen()` method for starting the Bun server
+- `fetch()` method for testing without starting a server
+- Full TypeScript type definitions with JSDoc documentation
+- Exported types: `BunaryApp`, `BunaryServer`, `RequestContext`, `RouteHandler`, `Middleware`

package/README.md

@@ -0,0 +1,180 @@
+# @bunary/http
+
+A lightweight, type-safe HTTP framework built exclusively for [Bun](https://bun.sh).
+
+Part of the [Bunary](https://github.com/bunary-dev) ecosystem - a Bun-first backend platform inspired by Laravel.
+
+## Features
+
+- 🚀 **Bun-native** - Uses `Bun.serve()` directly, no Node.js compatibility layer
+- 📦 **Zero dependencies** - Only depends on `@bunary/core`
+- 🔒 **Type-safe** - Full TypeScript support with strict types
+- ⚡ **Fast** - Minimal overhead, direct routing
+- 🧩 **Simple API** - Chainable route registration with automatic JSON serialization
+
+## Installation
+
+```bash
+bun add @bunary/http
+```
+
+## Quick Start
+
+```typescript
+import { createApp } from '@bunary/http';
+
+const app = createApp();
+
+app.get('/hello', () => ({ message: 'Hello, Bun!' }));
+
+app.listen({ port: 3000 });
+```
+
+## API
+
+### `createApp()`
+
+Creates a new Bunary application instance.
+
+```typescript
+import { createApp } from '@bunary/http';
+
+const app = createApp();
+```
+
+### Route Registration
+
+Register routes using chainable HTTP method helpers:
+
+```typescript
+app
+  .get('/users', () => ({ users: [] }))
+  .post('/users', async (ctx) => {
+    const body = await ctx.request.json();
+    return { id: 1, ...body };
+  })
+  .put('/users/:id', (ctx) => {
+    return { id: ctx.params.id, updated: true };
+  })
+  .delete('/users/:id', (ctx) => {
+    return { deleted: ctx.params.id };
+  })
+  .patch('/users/:id', (ctx) => {
+    return { patched: ctx.params.id };
+  });
+```
+
+### Path Parameters
+
+Path parameters are extracted automatically:
+
+```typescript
+app.get('/users/:id', (ctx) => {
+  return { userId: ctx.params.id };
+});
+
+app.get('/posts/:postId/comments/:commentId', (ctx) => {
+  const { postId, commentId } = ctx.params;
+  return { postId, commentId };
+});
+```
+
+### Query Parameters
+
+Query parameters are parsed from the URL:
+
+```typescript
+app.get('/search', (ctx) => {
+  const { q, page, limit } = ctx.query;
+  return { query: q, page, limit };
+});
+```
+
+### Request Context
+
+Route handlers receive a `RequestContext` object:
+
+```typescript
+interface RequestContext {
+  request: Request;  // Original Bun Request object
+  params: Record<string, string>;  // Path parameters
+  query: Record<string, string>;   // Query parameters
+}
+```
+
+### Response Handling
+
+Handlers can return various types - they're automatically serialized:
+
+```typescript
+// Objects/Arrays → JSON with Content-Type: application/json
+app.get('/json', () => ({ data: 'value' }));
+
+// Strings → text/plain
+app.get('/text', () => 'Hello, world!');
+
+// Response objects passed through unchanged
+app.get('/custom', () => new Response('Custom', { status: 201 }));
+
+// null/undefined → 204 No Content
+app.get('/empty', () => null);
+```
+
+### Starting the Server
+
+```typescript
+const server = app.listen({ port: 3000, hostname: 'localhost' });
+
+console.log(`Server running on ${server.hostname}:${server.port}`);
+
+// Stop the server when done
+server.stop();
+```
+
+### Testing Without Server
+
+Use `app.fetch()` to test handlers directly:
+
+```typescript
+const app = createApp();
+app.get('/hello', () => ({ message: 'hi' }));
+
+const response = await app.fetch(new Request('http://localhost/hello'));
+const data = await response.json();
+// { message: 'hi' }
+```
+
+## Error Handling
+
+Uncaught errors in handlers return a 500 response:
+
+```typescript
+app.get('/error', () => {
+  throw new Error('Something went wrong');
+});
+
+// Returns: 500 Internal Server Error
+// Body: { error: "Internal Server Error" }
+```
+
+## Types
+
+All types are exported for TypeScript users:
+
+```typescript
+import type { 
+  BunaryApp, 
+  BunaryServer,
+  RequestContext, 
+  RouteHandler,
+  Middleware 
+} from '@bunary/http';
+```
+
+## Requirements
+
+- Bun ≥ 1.0.0
+
+## License
+
+MIT

package/dist/app.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Create a new Bunary HTTP application instance.
+ *
+ * @returns BunaryApp instance with routing and middleware support
+ *
+ * @example
+ * ```ts
+ * import { createApp } from "@bunary/http";
+ *
+ * const app = createApp();
+ *
+ * app.get("/", () => ({ message: "Hello!" }));
+ * app.get("/users/:id", (ctx) => ({ id: ctx.params.id }));
+ *
+ * app.listen(3000);
+ * ```
+ */
+import type { BunaryApp } from "./types.js";
+/**
+ * Create a new Bunary HTTP application instance.
+ *
+ * Provides a simple, chainable API for defining routes and middleware.
+ * Objects returned from handlers are automatically serialized to JSON.
+ *
+ * @returns BunaryApp instance
+ *
+ * @example
+ * ```ts
+ * import { createApp } from "@bunary/http";
+ *
+ * const app = createApp();
+ *
+ * // Simple JSON response
+ * app.get("/", () => ({ message: "Hello, Bunary!" }));
+ *
+ * // Path parameters
+ * app.get("/users/:id", (ctx) => {
+ *   return { id: ctx.params.id };
+ * });
+ *
+ * // Query parameters
+ * app.get("/search", (ctx) => {
+ *   return { query: ctx.query.get("q") };
+ * });
+ *
+ * // Custom Response
+ * app.get("/custom", () => {
+ *   return new Response("Custom", { status: 201 });
+ * });
+ *
+ * app.listen(3000);
+ * ```
+ */
+export declare function createApp(): BunaryApp;
+//# sourceMappingURL=app.d.ts.map

package/dist/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EACX,SAAS,EAQT,MAAM,YAAY,CAAC;AA0FpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,SAAS,IAAI,SAAS,CAuOrC"}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @bunary/http - HTTP routing and middleware for Bunary
+ *
+ * A Bun-first HTTP layer providing routing, middleware, and server functionality.
+ *
+ * @example
+ * ```ts
+ * import { createApp } from "@bunary/http";
+ *
+ * const app = createApp();
+ *
+ * app.get("/", () => ({ message: "Hello, Bunary!" }));
+ * app.get("/users/:id", (ctx) => ({ id: ctx.params.id }));
+ *
+ * app.listen(3000);
+ * console.log("Server running on http://localhost:3000");
+ * ```
+ *
+ * @packageDocumentation
+ */
+export type { AppOptions, BunaryApp, BunaryServer, HandlerResponse, HttpMethod, Middleware, PathParams, QueryParams, RequestContext, Route, RouteHandler, } from "./types.js";
+export { createApp } from "./app.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,YAAY,EACX,UAAU,EACV,SAAS,EACT,YAAY,EACZ,eAAe,EACf,UAAU,EACV,UAAU,EACV,UAAU,EACV,WAAW,EACX,cAAc,EACd,KAAK,EACL,YAAY,GACZ,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,139 @@
+// @bun
+// src/app.ts
+function compilePath(path) {
+  const paramNames = [];
+  const regexString = path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_match, paramName) => {
+    paramNames.push(paramName);
+    return "([^/]+)";
+  });
+  return {
+    pattern: new RegExp(`^${regexString}$`),
+    paramNames
+  };
+}
+function extractParams(path, route) {
+  const match = path.match(route.pattern);
+  if (!match)
+    return {};
+  const params = {};
+  for (let i = 0;i < route.paramNames.length; i++) {
+    params[route.paramNames[i]] = match[i + 1];
+  }
+  return params;
+}
+function toResponse(result) {
+  if (result instanceof Response) {
+    return result;
+  }
+  if (result === null || result === undefined) {
+    return new Response(null, { status: 204 });
+  }
+  if (typeof result === "string") {
+    return new Response(result, {
+      status: 200,
+      headers: { "Content-Type": "text/plain;charset=utf-8" }
+    });
+  }
+  if (typeof result === "number") {
+    return new Response(String(result), {
+      status: 200,
+      headers: { "Content-Type": "text/plain;charset=utf-8" }
+    });
+  }
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function createApp() {
+  const routes = [];
+  const middlewares = [];
+  function addRoute(method, path, handler) {
+    const { pattern, paramNames } = compilePath(path);
+    routes.push({ method, path, pattern, paramNames, handler });
+    return app;
+  }
+  function findRoute(method, path) {
+    for (const route of routes) {
+      if (route.pattern.test(path)) {
+        if (route.method === method) {
+          return { route, params: extractParams(path, route) };
+        }
+      }
+    }
+    return null;
+  }
+  function hasMatchingPath(path) {
+    return routes.some((route) => route.pattern.test(path));
+  }
+  async function handleRequest(request) {
+    const url = new URL(request.url);
+    const path = url.pathname;
+    const method = request.method;
+    const match = findRoute(method, path);
+    if (!match) {
+      if (hasMatchingPath(path)) {
+        return new Response(JSON.stringify({ error: "Method not allowed" }), {
+          status: 405,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      return new Response(JSON.stringify({ error: "Not found" }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const ctx = {
+      request,
+      params: match.params,
+      query: url.searchParams
+    };
+    try {
+      let index = 0;
+      const next = async () => {
+        if (index < middlewares.length) {
+          const middleware = middlewares[index++];
+          return await middleware(ctx, next);
+        }
+        return await match.route.handler(ctx);
+      };
+      const result = await next();
+      return toResponse(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Internal server error";
+      return new Response(JSON.stringify({ error: message }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  }
+  const app = {
+    get: (path, handler) => addRoute("GET", path, handler),
+    post: (path, handler) => addRoute("POST", path, handler),
+    put: (path, handler) => addRoute("PUT", path, handler),
+    delete: (path, handler) => addRoute("DELETE", path, handler),
+    patch: (path, handler) => addRoute("PATCH", path, handler),
+    use: (middleware) => {
+      middlewares.push(middleware);
+      return app;
+    },
+    listen: (port = 3000, hostname = "localhost") => {
+      const server = Bun.serve({
+        port,
+        hostname,
+        fetch: handleRequest
+      });
+      return {
+        server,
+        port: server.port ?? port,
+        hostname: server.hostname ?? hostname,
+        stop: () => server.stop()
+      };
+    },
+    fetch: handleRequest
+  };
+  return app;
+}
+export {
+  createApp
+};

package/dist/types.d.ts

@@ -0,0 +1,171 @@
+/**
+ * HTTP method types supported by the router.
+ */
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+/**
+ * Query parameters parsed from the URL search string.
+ */
+export type QueryParams = Record<string, string | string[]>;
+/**
+ * Path parameters extracted from route patterns (e.g., `/users/:id` → `{ id: "123" }`).
+ */
+export type PathParams = Record<string, string>;
+/**
+ * Context object passed to route handlers containing request data.
+ *
+ * @example
+ * ```ts
+ * app.get("/users/:id", (ctx) => {
+ *   console.log(ctx.params.id);      // "123"
+ *   console.log(ctx.query.get("sort")); // "name"
+ *   return { id: ctx.params.id };
+ * });
+ * ```
+ */
+export interface RequestContext {
+    /** The original Bun Request object */
+    request: Request;
+    /** Path parameters extracted from the route pattern */
+    params: PathParams;
+    /** Query parameters from the URL search string */
+    query: URLSearchParams;
+}
+/**
+ * Return type for route handlers.
+ * - Objects/arrays are automatically serialized to JSON.
+ * - Response objects are passed through unchanged.
+ * - Primitives (string, number) are converted to text responses.
+ */
+export type HandlerResponse = Response | object | string | number | null | undefined;
+/**
+ * Route handler function that processes incoming requests.
+ *
+ * @param ctx - The request context containing request, params, and query
+ * @returns Response data (object for JSON, Response for custom, or primitive)
+ *
+ * @example
+ * ```ts
+ * const handler: RouteHandler = (ctx) => {
+ *   return { message: "Hello, World!" };
+ * };
+ * ```
+ */
+export type RouteHandler = (ctx: RequestContext) => HandlerResponse | Promise<HandlerResponse>;
+/**
+ * Middleware function for processing requests in a pipeline.
+ *
+ * @param ctx - The request context
+ * @param next - Function to call the next middleware or route handler
+ * @returns Response data or void (if next() handles it)
+ *
+ * @example
+ * ```ts
+ * const logger: Middleware = async (ctx, next) => {
+ *   console.log(`${ctx.request.method} ${ctx.request.url}`);
+ *   const response = await next();
+ *   console.log("Response sent");
+ *   return response;
+ * };
+ * ```
+ */
+export type Middleware = (ctx: RequestContext, next: () => Promise<HandlerResponse>) => HandlerResponse | Promise<HandlerResponse>;
+/**
+ * Internal route definition stored by the router.
+ */
+export interface Route {
+    /** HTTP method for this route */
+    method: HttpMethod;
+    /** Route path pattern (e.g., "/users/:id") */
+    path: string;
+    /** Compiled regex for matching */
+    pattern: RegExp;
+    /** Parameter names extracted from path */
+    paramNames: string[];
+    /** Handler function for this route */
+    handler: RouteHandler;
+}
+/**
+ * Configuration options for creating a Bunary app.
+ */
+export interface AppOptions {
+    /** Base path prefix for all routes (default: "") */
+    basePath?: string;
+}
+/**
+ * Server instance returned by app.listen().
+ */
+export interface BunaryServer {
+    /** The underlying Bun server */
+    server: ReturnType<typeof Bun.serve>;
+    /** Stop the server */
+    stop: () => void;
+    /** Port the server is listening on */
+    port: number;
+    /** Hostname the server is bound to */
+    hostname: string;
+}
+/**
+ * The Bunary application instance for HTTP routing and middleware.
+ *
+ * @example
+ * ```ts
+ * const app = createApp();
+ *
+ * app.get("/", () => ({ message: "Hello!" }));
+ * app.get("/users/:id", (ctx) => ({ id: ctx.params.id }));
+ *
+ * app.listen(3000);
+ * ```
+ */
+export interface BunaryApp {
+    /**
+     * Register a GET route.
+     * @param path - URL path pattern (supports :param syntax)
+     * @param handler - Function to handle requests
+     */
+    get: (path: string, handler: RouteHandler) => BunaryApp;
+    /**
+     * Register a POST route.
+     * @param path - URL path pattern (supports :param syntax)
+     * @param handler - Function to handle requests
+     */
+    post: (path: string, handler: RouteHandler) => BunaryApp;
+    /**
+     * Register a PUT route.
+     * @param path - URL path pattern (supports :param syntax)
+     * @param handler - Function to handle requests
+     */
+    put: (path: string, handler: RouteHandler) => BunaryApp;
+    /**
+     * Register a DELETE route.
+     * @param path - URL path pattern (supports :param syntax)
+     * @param handler - Function to handle requests
+     */
+    delete: (path: string, handler: RouteHandler) => BunaryApp;
+    /**
+     * Register a PATCH route.
+     * @param path - URL path pattern (supports :param syntax)
+     * @param handler - Function to handle requests
+     */
+    patch: (path: string, handler: RouteHandler) => BunaryApp;
+    /**
+     * Add middleware to the request pipeline.
+     * Middleware executes in registration order.
+     * @param middleware - Middleware function
+     */
+    use: (middleware: Middleware) => BunaryApp;
+    /**
+     * Start the HTTP server.
+     * @param port - Port number to listen on (default: 3000)
+     * @param hostname - Hostname to bind to (default: "localhost")
+     * @returns Server instance with stop() method
+     */
+    listen: (port?: number, hostname?: string) => BunaryServer;
+    /**
+     * Handle an incoming request (used internally and for testing).
+     * @param request - The incoming Request object
+     * @returns Response object
+     */
+    fetch: (request: Request) => Promise<Response>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@bunary/http",
+  "version": "0.0.1",
+  "description": "HTTP routing and middleware for Bunary - a Bun-first backend framework inspired by Laravel",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun && bunx tsc -p tsconfig.build.json",
+    "typecheck": "bunx tsc --noEmit",
+    "test": "bun test",
+    "lint": "bunx biome check ./src"
+  },
+  "keywords": [
+    "bunary",
+    "bun",
+    "http",
+    "router",
+    "middleware",
+    "framework"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bunary-dev/http.git"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "dependencies": {
+    "@bunary/core": "^0.0.2"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "bun-types": "^1.0.0",
+    "typescript": "^5.0.0"
+  }
+}