bxo 0.0.5-dev.8 → 0.0.5-dev.81

package/README.md

@@ -1,579 +1,380 @@
-# 🦊 BXO - A Type-Safe Web Framework for Bun
+# bxo
 
-BXO is a fast, lightweight, and fully type-safe web framework built specifically for Bun runtime. Inspired by Elysia, it provides excellent developer experience with automatic type inference, Zod validation, and a powerful plugin system.
+A fast, lightweight web framework for Bun with built-in Zod validation and lifecycle hooks.
 
-## ✨ Features
+## Features
 
-- 🚀 **Built for Bun** - Leverages Bun's native HTTP server for maximum performance
-- 🔒 **Type-Safe** - Full TypeScript support with automatic type inference
-- 📋 **Zod Validation** - Built-in request/response validation using Zod schemas
-- 🔌 **Plugin System** - Extensible architecture with lifecycle hooks
-- 🎣 **Lifecycle Hooks** - Complete control over server and request/response lifecycle
-- 🔄 **Hot Reload** - Automatic server restart on file changes during development
-- 🎮 **Server Management** - Programmatic start, stop, and restart capabilities
-- 📊 **Status Monitoring** - Built-in server status and runtime statistics
-- 📦 **Zero Dependencies** - Only depends on Zod for validation
-- ⚡ **Fast** - Minimal overhead with efficient routing
+- **Type-safe routing** with Zod schema validation
+- **WebSocket support** with clean API
+- **Lifecycle hooks** for middleware and plugins
+- **Plugin system** for extending functionality
+- **Built-in CORS support** via plugin
+- **Fast performance** leveraging Bun's native HTTP server
 
-## 🚀 Quick Start
-
-### Installation
+## Installation
 
 ```bash
-bun add zod
+bun install
 ```
 
-### Basic Usage
+## Quick Start
 
 ```typescript
-import BXO, { z } from './index';
-
-const app = new BXO()
-  .get('/', async (ctx) => {
-    return { message: 'Hello, BXO!' };
-  })
-  .start(3000);
-```
+import BXO from "./src/index";
+import { cors } from "./plugins";
 
-## 📚 Documentation
+const app = new BXO();
 
-### HTTP Handlers
+// Use CORS plugin
+app.use(cors());
 
-BXO supports all standard HTTP methods with fluent chaining:
+// Define routes
+app.get("/", (ctx) => ctx.json({ message: "Hello World!" }));
 
-```typescript
-const app = new BXO()
-  // Simple handler
-  .get('/simple', async (ctx) => {
-    return { message: 'Hello World' };
-  })
-  
-  // With validation
-  .post('/users', async (ctx) => {
-    // ctx.body is fully typed
-    return { created: ctx.body };
-  }, {
-    body: z.object({
-      name: z.string(),
-      email: z.string().email()
-    })
-  })
-  
-  // Path parameters
-  .get('/users/:id', async (ctx) => {
-    // ctx.params.id is typed as UUID string
-    return { user: { id: ctx.params.id } };
-  }, {
-    params: z.object({ 
-      id: z.string().uuid() 
-    }),
-    query: z.object({ 
-      include: z.string().optional() 
-    })
-  })
-  
-  // All HTTP methods supported
-  .put('/users/:id', handler)
-  .delete('/users/:id', handler)
-  .patch('/users/:id', handler);
+app.start();
 ```
 
-### Context Object
+## WebSocket Support
 
-The context object (`ctx`) provides access to request data and response configuration:
+BXO provides built-in WebSocket support with a clean, intuitive API:
 
 ```typescript
-interface Context<TConfig> {
-  params: InferredParamsType;    // Path parameters
-  query: InferredQueryType;      // Query string parameters  
-  body: InferredBodyType;        // Request body
-  headers: InferredHeadersType;  // Request headers
-  request: Request;              // Original Request object
-  set: {                         // Response configuration
-    status?: number;
-    headers?: Record<string, string>;
-  };
-  user?: any;                    // Added by auth plugin
-  [key: string]: any;            // Extended by plugins
-}
-```
+import BXO from "./src";
 
-### Validation Configuration
+const app = new BXO();
 
-Each route can specify validation schemas for different parts of the request:
+// WebSocket route
+app.ws("/ws", {
+    open(ws) {
+        console.log("WebSocket connection opened");
+        ws.send("Welcome to BXO WebSocket!");
+    },
+    
+    message(ws, message) {
+        console.log("Received message:", message);
+        // Echo the message back
+        ws.send(`Echo: ${message}`);
+    },
+    
+    close(ws, code, reason) {
+        console.log(`WebSocket connection closed: ${code} ${reason}`);
+    },
+    
+    ping(ws, data) {
+        console.log("Ping received:", data);
+    },
+    
+    pong(ws, data) {
+        console.log("Pong received:", data);
+    }
+});
+
+// WebSocket with path parameters
+app.ws("/chat/:room", {
+    open(ws) {
+        const room = ws.data?.room || 'unknown';
+        console.log(`WebSocket connection opened for room: ${room}`);
+        ws.send(`Welcome to chat room: ${room}`);
+    },
+    
+    message(ws, message) {
+        const room = ws.data?.room || 'unknown';
+        console.log(`Message in room ${room}:`, message);
+        ws.send(`[${room}] Echo: ${message}`);
+    }
+});
 
-```typescript
-const config = {
-  params: z.object({ id: z.string().uuid() }),
-  query: z.object({ 
-    page: z.coerce.number().default(1),
-    limit: z.coerce.number().max(100).default(10)
-  }),
-  body: z.object({
-    name: z.string().min(1),
-    email: z.string().email()
-  }),
-  headers: z.object({
-    'content-type': z.literal('application/json')
-  })
-};
-
-app.post('/api/users/:id', async (ctx) => {
-  // All properties are fully typed based on schemas
-  const { id } = ctx.params;           // string (UUID)
-  const { page, limit } = ctx.query;   // number, number
-  const { name, email } = ctx.body;    // string, string
-}, config);
+app.start();
 ```
 
-## 🔌 Plugin System
+### WebSocket Handler Events
 
-BXO has a powerful plugin system with lifecycle hooks. Plugins are separate modules imported from `./plugins`.
+- `open(ws)` - Called when a WebSocket connection is established
+- `message(ws, message)` - Called when a message is received
+- `close(ws, code, reason)` - Called when the connection is closed
+- `drain(ws)` - Called when the WebSocket is ready for more data
+- `ping(ws, data)` - Called when a ping is received
+- `pong(ws, data)` - Called when a pong is received
 
-### Available Plugins
+### WebSocket Features
 
-#### CORS Plugin
+- **Path parameters** - Support for dynamic routes like `/chat/:room`
+- **Automatic upgrade** - HTTP requests to WebSocket routes are automatically upgraded
+- **Type safety** - Full TypeScript support with proper typing
+- **Error handling** - Built-in error handling for WebSocket events
+- **Data attachment** - Access to path information via `ws.data`
 
-```typescript
-import { cors } from './plugins';
+## Lifecycle Hooks
 
-app.use(cors({
-  origin: ['http://localhost:3000', 'https://example.com'],
-  methods: ['GET', 'POST', 'PUT', 'DELETE'],
-  allowedHeaders: ['Content-Type', 'Authorization'],
-  credentials: true,
-  maxAge: 86400
-}));
-```
+BXO provides powerful lifecycle hooks that allow you to intercept and modify requests and responses at different stages:
 
-#### Logger Plugin
+### beforeRequest
+Runs before any route processing. Can modify the request or return a response to short-circuit processing.
 
 ```typescript
-import { logger } from './plugins';
-
-app.use(logger({
-  format: 'simple',        // 'simple' | 'detailed' | 'json'
-  includeBody: false,      // Log request/response bodies
-  includeHeaders: false    // Log headers
-}));
+app.beforeRequest(async (req) => {
+  console.log(`${req.method} ${req.url}`);
+  return req; // Continue with request
+});
 ```
 
-#### Authentication Plugin
+### afterRequest
+Runs after route processing but before the response is sent. Can modify the final response.
 
 ```typescript
-import { auth, createJWT } from './plugins';
-
-app.use(auth({
-  type: 'jwt',                    // 'jwt' | 'bearer' | 'apikey'
-  secret: 'your-secret-key',
-  exclude: ['/login', '/health'], // Skip auth for these paths
-  verify: async (token, ctx) => {
-    // Custom token verification
-    return { user: 'data' };
-  }
-}));
-
-// Create JWT tokens
-const token = createJWT(
-  { userId: 123, role: 'admin' }, 
-  'secret', 
-  3600 // expires in 1 hour
-);
+app.afterRequest(async (req, res) => {
+  res.headers.set("X-Response-Time", Date.now().toString());
+  return res;
+});
 ```
 
-#### Rate Limiting Plugin
+### beforeResponse
+Runs after the route handler but before response headers are merged. Useful for modifying response metadata.
 
 ```typescript
-import { rateLimit } from './plugins';
-
-app.use(rateLimit({
-  max: 100,                    // Max requests
-  window: 60,                  // Time window in seconds
-  exclude: ['/health'],        // Skip rate limiting for these paths
-  keyGenerator: (ctx) => {     // Custom key generation
-    return ctx.request.headers.get('x-api-key') || 'default';
-  },
-  message: 'Too many requests',
-  statusCode: 429
-}));
+app.beforeResponse(async (res) => {
+  res.headers.set("X-Custom-Header", "value");
+  return res;
+});
 ```
 
-### Creating Custom Plugins
+### onError
+Runs when an error occurs during request processing. Can return a custom error response.
 
 ```typescript
-const customPlugin = {
-  name: 'custom',
-  onRequest: async (ctx) => {
-    console.log('Before request processing');
-    ctx.startTime = Date.now();
-  },
-  onResponse: async (ctx, response) => {
-    console.log(`Request took ${Date.now() - ctx.startTime}ms`);
-    return response;
-  },
-  onError: async (ctx, error) => {
-    console.error('Request failed:', error.message);
-    return { error: 'Custom error response' };
-  }
-};
-
-app.use(customPlugin);
+app.onError(async (error, req) => {
+  console.error(`Error: ${error.message}`);
+  return new Response("Internal Server Error", { status: 500 });
+});
 ```
 
-## 🎣 Lifecycle Hooks
+## Plugins
 
-BXO provides comprehensive lifecycle hooks with a consistent before/after pattern for both server and request lifecycle:
+### CORS Plugin
 
-### Server Lifecycle Hooks
+The CORS plugin provides comprehensive Cross-Origin Resource Sharing support:
 
 ```typescript
-app
-  .onBeforeStart(() => {
-    console.log('🔧 Preparing to start server...');
-  })
-  .onAfterStart(() => {
-    console.log('✅ Server fully started and ready!');
-  })
-  .onBeforeStop(() => {
-    console.log('🔧 Preparing to stop server...');
-  })
-  .onAfterStop(() => {
-    console.log('✅ Server fully stopped!');
-  })
-  .onBeforeRestart(() => {
-    console.log('🔧 Preparing to restart server...');
-  })
-  .onAfterRestart(() => {
-    console.log('✅ Server restart completed!');
-  });
-```
+import { cors } from "./plugins";
 
-### Request Lifecycle Hooks
-
-```typescript
-app
-  .onRequest((ctx) => {
-    console.log(`📨 ${ctx.request.method} ${ctx.request.url}`);
-  })
-  .onResponse((ctx, response) => {
-    console.log(`📤 Response sent`);
-    return response; // Can modify response
-  })
-  .onError((ctx, error) => {
-    console.error(`💥 Error:`, error.message);
-    return { error: 'Something went wrong' }; // Can provide custom error response
-  });
+app.use(cors({
+  origin: ["http://localhost:3000", "https://myapp.com"],
+  methods: ["GET", "POST", "PUT", "DELETE"],
+  credentials: true
+}));
 ```
 
-## 🔄 Hot Reload & Server Management
-
-BXO includes built-in hot reload and comprehensive server management capabilities:
+### OpenAPI Plugin
 
-### Hot Reload
+The OpenAPI plugin automatically generates OpenAPI 3.0 documentation with support for tags, security schemes, and comprehensive route metadata:
 
 ```typescript
-const app = new BXO();
-
-// Enable hot reload - server will restart when files change
-app.enableHotReload(['./']); // Watch current directory
-
-// Hot reload will automatically restart the server when:
-// - Any .ts or .js file changes in watched directories
-// - Server lifecycle hooks are properly executed during restart
+import { openapi } from "./plugins";
+
+app.use(openapi({
+  path: "/docs",                    // Swagger UI endpoint
+  jsonPath: "/openapi.json",        // OpenAPI JSON endpoint
+  defaultTags: ["API"],             // Default tags for routes
+  securitySchemes: {                // Define security schemes
+    bearerAuth: {
+      type: "http",
+      scheme: "bearer",
+      bearerFormat: "JWT",
+      description: "JWT token for authentication"
+    },
+    apiKeyAuth: {
+      type: "apiKey",
+      in: "header",
+      name: "X-API-Key",
+      description: "API key for authentication"
+    }
+  },
+  globalSecurity: [                 // Global security requirements
+    { bearerAuth: [] },
+    { apiKeyAuth: [] }
+  ],
+  openapiConfig: {                  // Additional OpenAPI config
+    info: {
+      title: "My API",
+      version: "1.0.0",
+      description: "API description"
+    }
+  }
+}));
 ```
 
-### Server Management
-
-```typescript
-const app = new BXO();
-
-// Start server
-await app.start(3000, 'localhost');
-
-// Check if server is running
-if (app.isServerRunning()) {
-  console.log('Server is running!');
-}
-
-// Get server information
-const info = app.getServerInfo();
-console.log(info); // { running: true, hotReload: true, watchedFiles: ['./'] }
+#### Route Metadata
 
-// Restart server programmatically
-await app.restart(3000, 'localhost');
-
-// Stop server gracefully
-await app.stop();
-
-// Backward compatibility - listen() still works
-await app.listen(3000); // Same as app.start(3000)
-```
-
-### Development vs Production
+Routes can include detailed metadata for better OpenAPI documentation:
 
 ```typescript
-const app = new BXO();
-
-if (process.env.NODE_ENV === 'development') {
-  // Enable hot reload in development
-  app.enableHotReload(['./src', './routes']);
-}
-
-// Add server management endpoints for development
-if (process.env.NODE_ENV === 'development') {
-  app.post('/dev/restart', async (ctx) => {
-    setTimeout(() => app.restart(3000), 100);
-    return { message: 'Server restart initiated' };
-  });
-  
-  app.get('/dev/status', async (ctx) => {
-    return {
-      ...app.getServerInfo(),
-      uptime: process.uptime(),
-      memory: process.memoryUsage()
-    };
-  });
-}
+app.get("/users/:id", (ctx) => {
+  const id = ctx.params.id
+  return { user: { id, name: "John Doe" } }
+}, {
+  detail: {
+    tags: ["Users"],                    // Route tags for grouping
+    summary: "Get user by ID",          // Operation summary
+    description: "Retrieve user details", // Detailed description
+    security: [{ bearerAuth: [] }],     // Route-specific security
+    params: {                           // Parameter documentation
+      id: z.string().describe("User ID")
+    }
+  }
+})
 ```
 
-## 🌟 Complete Example
+#### Supported Metadata Fields
 
-```typescript
-import BXO, { z } from './index';
-import { cors, logger, auth, rateLimit, createJWT } from './plugins';
+- `tags`: Array of tags for grouping operations
+- `summary`: Short description of the operation
+- `description`: Detailed description of the operation
+- `security`: Security requirements for the route
+- `params`: Path parameter schemas and descriptions
+- `query`: Query parameter schemas
+- `hidden`: Set to `true` to exclude from OpenAPI docs
 
-const app = new BXO();
+### Creating Custom Plugins
 
-// Enable hot reload for development
-app.enableHotReload(['./']);
+Plugins are just BXO instances with lifecycle hooks:
 
-// Add plugins
-app
-  .use(logger({ format: 'simple' }))
-  .use(cors({ 
-    origin: ['http://localhost:3000'],
-    credentials: true 
-  }))
-  .use(rateLimit({ 
-    max: 100, 
-    window: 60,
-    exclude: ['/health'] 
-  }))
-  .use(auth({ 
-    type: 'jwt', 
-    secret: 'your-secret-key',
-    exclude: ['/', '/login', '/health']
-  }));
-
-// Comprehensive lifecycle hooks
-app
-  .onBeforeStart(() => console.log('🔧 Preparing server startup...'))
-  .onAfterStart(() => console.log('✅ Server ready!'))
-  .onBeforeRestart(() => console.log('🔄 Restarting server...'))
-  .onAfterRestart(() => console.log('✅ Server restarted!'))
-  .onError((ctx, error) => ({ 
-    error: 'Internal server error',
-    timestamp: new Date().toISOString()
-  }));
-
-// Routes
-app
-  .get('/health', async () => ({ 
-    status: 'ok', 
-    timestamp: new Date().toISOString(),
-    server: app.getServerInfo()
-  }))
-  
-  .post('/login', async (ctx) => {
-    const { username, password } = ctx.body;
-    
-    if (username === 'admin' && password === 'password') {
-      const token = createJWT(
-        { username, role: 'admin' }, 
-        'your-secret-key'
-      );
-      return { token, user: { username, role: 'admin' } };
-    }
-    
-    ctx.set.status = 401;
-    return { error: 'Invalid credentials' };
-  }, {
-    body: z.object({
-      username: z.string(),
-      password: z.string()
-    })
-  })
-  
-  .get('/users/:id', async (ctx) => {
-    return { 
-      user: { 
-        id: ctx.params.id,
-        include: ctx.query.include 
-      } 
-    };
-  }, {
-    params: z.object({ id: z.string().uuid() }),
-    query: z.object({ include: z.string().optional() })
-  })
-  
-  .post('/users', async (ctx) => {
-    return { created: ctx.body };
-  }, {
-    body: z.object({
-      name: z.string(),
-      email: z.string().email()
-    })
-  })
-  
-  .get('/protected', async (ctx) => {
-    // ctx.user available from auth plugin
-    return { 
-      message: 'Protected resource', 
-      user: ctx.user 
-    };
-  })
-  
-  // Server management endpoints
-  .post('/restart', async (ctx) => {
-    setTimeout(() => app.restart(3000), 100);
-    return { message: 'Server restart initiated' };
-  })
+```typescript
+function loggingPlugin() {
+  const plugin = new BXO();
   
-  .get('/status', async (ctx) => {
-    return {
-      ...app.getServerInfo(),
-      uptime: process.uptime(),
-      memory: process.memoryUsage()
-    };
+  plugin.beforeRequest(async (req) => {
+    console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
+    return req;
   });
+  
+  return plugin;
+}
 
-// Start server with hot reload
-app.start(3000);
+app.use(loggingPlugin());
 ```
 
-## 🧪 Testing Endpoints
-
-With the example server running, test these endpoints:
-
-```bash
-# Health check
-curl http://localhost:3000/health
+## Route Validation
 
-# Login to get token
-curl -X POST http://localhost:3000/login \
-  -H "Content-Type: application/json" \
-  -d '{"username": "admin", "password": "password"}'
+Define Zod schemas for request validation:
 
-# Create user
-curl -X POST http://localhost:3000/users \
-  -H "Content-Type: application/json" \
-  -d '{"name": "John Doe", "email": "john@example.com"}'
+```typescript
+import { z } from "bxo";
+
+const UserSchema = z.object({
+  name: z.string().min(1),
+  email: z.string().email()
+});
+
+app.post("/users", async (ctx) => {
+  const user = ctx.body; // Already validated by UserSchema
+  return ctx.json({ id: 1, ...user });
+}, {
+  body: UserSchema
+});
+```
 
-# Get user with validation
-curl "http://localhost:3000/users/123e4567-e89b-12d3-a456-426614174000?include=profile"
+## Multipart/Form-Data Parsing
 
-# Access protected route (use token from login)
-curl http://localhost:3000/protected \
-  -H "Authorization: Bearer YOUR_JWT_TOKEN"
+BXO automatically parses multipart/form-data into nested objects and arrays before Zod validation:
 
-# Check server status
-curl http://localhost:3000/status
+### Nested Objects
+Form fields like `profile[name]` are automatically converted to nested objects:
 
-# Restart server programmatically
-curl -X POST http://localhost:3000/restart
+```typescript
+const UserFormSchema = z.object({
+  name: z.string(),
+  email: z.string().email(),
+  profile: z.object({
+    name: z.string()
+  })
+});
+
+app.post("/users", async (ctx) => {
+  // Form data: profile[name]="John" becomes { profile: { name: "John" } }
+  console.log(ctx.body); // { name: "...", email: "...", profile: { name: "John" } }
+  return ctx.json({ success: true, data: ctx.body });
+}, {
+  body: UserFormSchema
+});
 ```
 
-## 📖 API Reference
-
-### BXO Class Methods
-
-#### HTTP Methods
-- `get(path, handler, config?)` - Handle GET requests
-- `post(path, handler, config?)` - Handle POST requests  
-- `put(path, handler, config?)` - Handle PUT requests
-- `delete(path, handler, config?)` - Handle DELETE requests
-- `patch(path, handler, config?)` - Handle PATCH requests
-
-#### Plugins & Hooks
-- `use(plugin)` - Add a plugin
-- `onBeforeStart(handler)` - Before server start hook
-- `onAfterStart(handler)` - After server start hook
-- `onBeforeStop(handler)` - Before server stop hook
-- `onAfterStop(handler)` - After server stop hook
-- `onBeforeRestart(handler)` - Before server restart hook
-- `onAfterRestart(handler)` - After server restart hook
-- `onRequest(handler)` - Global request hook
-- `onResponse(handler)` - Global response hook
-- `onError(handler)` - Global error hook
-
-#### Server Management
-- `start(port?, hostname?)` - Start the server
-- `stop()` - Stop the server gracefully
-- `restart(port?, hostname?)` - Restart the server
-- `listen(port?, hostname?)` - Start the server (backward compatibility)
-- `isServerRunning()` - Check if server is running
-- `getServerInfo()` - Get server status information
-
-#### Hot Reload
-- `enableHotReload(watchPaths?)` - Enable hot reload with file watching
-
-### Route Configuration
+### Arrays
+Form fields like `items[0]`, `items[1]` are automatically converted to arrays:
 
 ```typescript
-interface RouteConfig {
-  params?: z.ZodSchema<any>;   // Path parameter validation
-  query?: z.ZodSchema<any>;    // Query string validation  
-  body?: z.ZodSchema<any>;     // Request body validation
-  headers?: z.ZodSchema<any>;  // Header validation
-}
+const ItemsSchema = z.object({
+  items: z.array(z.string()),
+  tags: z.array(z.string()),
+  profile: z.object({
+    name: z.string(),
+    age: z.string().transform(val => parseInt(val, 10))
+  })
+});
+
+app.post("/items", async (ctx) => {
+  // Form data: items[0]="Apple", items[1]="Banana" becomes { items: ["Apple", "Banana"] }
+  console.log(ctx.body); // { items: ["Apple", "Banana"], tags: [...], profile: {...} }
+  return ctx.json({ success: true, data: ctx.body });
+}, {
+  body: ItemsSchema
+});
 ```
 
-### Plugin Interface
+### Deep Nested Array Objects
+Form fields like `workspace_items[0][id]`, `workspace_items[0][type]` are automatically converted to arrays of objects:
 
 ```typescript
-interface Plugin {
-  name?: string;
-  onRequest?: (ctx: Context) => Promise<void> | void;
-  onResponse?: (ctx: Context, response: any) => Promise<any> | any;
-  onError?: (ctx: Context, error: Error) => Promise<any> | any;
-}
+const WorkspaceSchema = z.object({
+  id: z.string(),
+  workspace_items: z.array(z.object({
+    id: z.string(),
+    type: z.string(),
+    value: z.string(),
+    options: z.string(),
+    label: z.string()
+  }))
+});
+
+app.post("/workspace", async (ctx) => {
+  // Form data: workspace_items[0][id]="item1", workspace_items[0][type]="Link" 
+  // becomes { workspace_items: [{ id: "item1", type: "Link", ... }] }
+  console.log(ctx.body); // { id: "...", workspace_items: [{ id: "item1", type: "Link", ... }] }
+  return ctx.json({ success: true, data: ctx.body });
+}, {
+  body: WorkspaceSchema
+});
 ```
 
-## 🛠️ Development
+### Supported Patterns
+- **Nested objects**: `profile[name]`, `settings[theme]` → `{ profile: { name: "..." }, settings: { theme: "..." } }`
+- **Arrays**: `items[0]`, `items[1]` → `{ items: ["...", "..."] }`
+- **Deep nested array objects**: `workspace_items[0][id]`, `workspace_items[0][type]` → `{ workspace_items: [{ id: "...", type: "..." }] }`
+- **Duplicate keys**: Multiple values with same key → `{ tags: ["tag1", "tag2"] }`
 
-### Running the Example
+## Running
 
 ```bash
-# Run with hot reload enabled
-bun run example.ts
-
-# The server will automatically restart when you edit any .ts/.js files!
+bun run ./src/index.ts
 ```
 
-### Project Structure
+Or run the examples:
 
-```
-bxo/
-├── index.ts              # Main BXO framework
-├── plugins/
-│   ├── index.ts          # Plugin exports
-│   ├── cors.ts           # CORS plugin
-│   ├── logger.ts         # Logger plugin
-│   ├── auth.ts           # Authentication plugin
-│   └── ratelimit.ts      # Rate limiting plugin
-├── example.ts            # Usage example
-├── package.json
-└── README.md
-```
-
-## 🤝 Contributing
+```bash
+# CORS example
+bun run ./example/cors-example.ts
 
-BXO is designed to be simple and extensible. Contributions are welcome!
+# Multipart form data parsing example
+bun run ./example/multipart-example.ts
+```
 
-## 📄 License
+## Examples
 
-MIT License - feel free to use BXO in your projects!
+Check out the `example/` directory for more usage examples:
 
----
+- `cors-example.ts` - Demonstrates CORS plugin and lifecycle hooks
+- `openapi-example.ts` - Demonstrates OpenAPI plugin with tags and security
+- `websocket-example.ts` - Demonstrates WebSocket functionality with interactive HTML client
+- `multipart-example.ts` - Demonstrates multipart/form-data parsing with nested objects and arrays
+- `index.ts` - Basic routing example
 
-Built with ❤️ for the Bun ecosystem
+This project was created using `bun init` in bun v1.2.3. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.