bxo 0.0.5-dev.2 → 0.0.5-dev.20

package/example.ts

@@ -1,13 +1,39 @@
 import BXO, { z } from './index';
 import { cors, logger, auth, rateLimit, createJWT } from './plugins';
 
+// Create a simple API plugin that defines its own routes
+function createApiPlugin(): BXO {
+  const apiPlugin = new BXO();
+  
+  apiPlugin
+    .get('/api/info', async (ctx) => {
+      return { 
+        name: 'BXO API Plugin',
+        version: '1.0.0',
+        endpoints: ['/api/info', '/api/ping', '/api/time']
+      };
+    })
+    .get('/api/ping', async (ctx) => {
+      return { ping: 'pong', timestamp: Date.now() };
+    })
+    .get('/api/time', async (ctx) => {
+      return { time: new Date().toISOString() };
+    })
+    .post('/api/echo', async (ctx) => {
+      return { echo: ctx.body };
+    }, {
+      body: z.object({
+        message: z.string()
+      })
+    });
+    
+  return apiPlugin;
+}
+
 // Create the app instance
 const app = new BXO();
 
-// Enable hot reload
-app.enableHotReload(['./']); // Watch current directory
-
-// Add plugins
+// Add plugins (including our new API plugin)
 app
   .use(logger({ format: 'simple' }))
   .use(cors({ 
@@ -22,8 +48,9 @@ app
   .use(auth({ 
     type: 'jwt', 
     secret: 'your-secret-key',
-    exclude: ['/', '/login', '/health']
-  }));
+    exclude: ['/', '/login', '/health', '/api/*']
+  }))
+  .use(createApiPlugin()); // Add our plugin with actual routes
 
 // Add simplified lifecycle hooks
 app
@@ -39,12 +66,6 @@ app
   .onAfterStop(() => {
     console.log('✅ Server fully stopped!');
   })
-  .onBeforeRestart(() => {
-    console.log('🔧 Preparing to restart server...');
-  })
-  .onAfterRestart(() => {
-    console.log('✅ Server restart completed!');
-  })
   .onRequest((ctx) => {
     console.log(`📨 Processing ${ctx.request.method} ${ctx.request.url}`);
   })
@@ -116,13 +137,6 @@ app
     return { message: 'This is protected', user: ctx.user };
   })
 
-  // Server control endpoints
-  .post('/restart', async (ctx) => {
-    // Restart the server
-    setTimeout(() => app.restart(3000), 100);
-    return { message: 'Server restart initiated' };
-  })
-
   .get('/status', async (ctx) => {
     return {
       ...app.getServerInfo(),
@@ -162,12 +176,12 @@ console.log(`
 🦊 BXO Framework with Hot Reload
 
 ✨ Features Enabled:
-- 🔄 Hot reload (edit any .ts/.js file to restart)
 - 🎣 Full lifecycle hooks (before/after pattern)
 - 🔒 JWT authentication
 - 📊 Rate limiting  
 - 🌐 CORS support
 - 📝 Request logging
+- 🔌 API Plugin with routes
 
 🧪 Try these endpoints:
 - GET  /simple
@@ -177,7 +191,14 @@ console.log(`
 - POST /login (with JSON body: {"username": "admin", "password": "password"})
 - GET  /protected (requires Bearer token from /login)
 - GET  /status (server statistics)
-- POST /restart (restart server programmatically)
+
+🔌 API Plugin endpoints:
+- GET  /api/info (plugin information)
+- GET  /api/ping (ping pong)
+- GET  /api/time (current time)
+- POST /api/echo (echo message: {"message": "hello"})
 
 💡 Edit this file and save to see hot reload in action!
-`); 
+`); 
+
+console.log(app.routes)

package/index.ts

@@ -3,6 +3,18 @@ import { z } from 'zod';
 // Type utilities for extracting types from Zod schemas
 type InferZodType<T> = T extends z.ZodType<infer U> ? U : never;
 
+// OpenAPI detail information
+interface RouteDetail {
+  summary?: string;
+  description?: string;
+  tags?: string[];
+  operationId?: string;
+  deprecated?: boolean;
+  produces?: string[];
+  consumes?: string[];
+  [key: string]: any; // Allow additional OpenAPI properties
+}
+
 // Configuration interface for route handlers
 interface RouteConfig {
   params?: z.ZodSchema<any>;
@@ -10,6 +22,7 @@ interface RouteConfig {
   body?: z.ZodSchema<any>;
   headers?: z.ZodSchema<any>;
   response?: z.ZodSchema<any>;
+  detail?: RouteDetail;
 }
 
 // Context type that's fully typed based on the route configuration
@@ -18,18 +31,17 @@ export type Context<TConfig extends RouteConfig = {}> = {
   query: TConfig['query'] extends z.ZodSchema<any> ? InferZodType<TConfig['query']> : Record<string, string | undefined>;
   body: TConfig['body'] extends z.ZodSchema<any> ? InferZodType<TConfig['body']> : unknown;
   headers: TConfig['headers'] extends z.ZodSchema<any> ? InferZodType<TConfig['headers']> : Record<string, string>;
+  path: string;
   request: Request;
   set: {
     status?: number;
     headers?: Record<string, string>;
   };
-  // Extended properties that can be added by plugins
-  user?: any;
   [key: string]: any;
 };
 
 // Handler function type
-type Handler<TConfig extends RouteConfig = {}> = (ctx: Context<TConfig>) => Promise<any> | any;
+type Handler<TConfig extends RouteConfig = {}, EC = {}> = (ctx: Context<TConfig> & EC) => Promise<any> | any;
 
 // Route definition
 interface Route {
@@ -39,73 +51,77 @@ interface Route {
   config?: RouteConfig;
 }
 
+// WebSocket handler interface
+interface WebSocketHandler {
+  onOpen?: (ws: any) => void;
+  onMessage?: (ws: any, message: string | Buffer) => void;
+  onClose?: (ws: any, code?: number, reason?: string) => void;
+  onError?: (ws: any, error: Error) => void;
+}
+
+// WebSocket route definition
+interface WSRoute {
+  path: string;
+  handler: WebSocketHandler;
+}
+
 // Lifecycle hooks
 interface LifecycleHooks {
-  onBeforeStart?: () => Promise<void> | void;
-  onAfterStart?: () => Promise<void> | void;
-  onBeforeStop?: () => Promise<void> | void;
-  onAfterStop?: () => Promise<void> | void;
-  onBeforeRestart?: () => Promise<void> | void;
-  onAfterRestart?: () => Promise<void> | void;
-  onRequest?: (ctx: Context) => Promise<void> | void;
-  onResponse?: (ctx: Context, response: any) => Promise<any> | any;
-  onError?: (ctx: Context, error: Error) => Promise<any> | any;
+  onBeforeStart?: (instance: BXO) => Promise<void> | void;
+  onAfterStart?: (instance: BXO) => Promise<void> | void;
+  onBeforeStop?: (instance: BXO) => Promise<void> | void;
+  onAfterStop?: (instance: BXO) => Promise<void> | void;
+  onRequest?: (ctx: Context, instance: BXO) => Promise<void> | void;
+  onResponse?: (ctx: Context, response: any, instance: BXO) => Promise<any> | any;
+  onError?: (ctx: Context, error: Error, instance: BXO) => Promise<any> | any;
 }
 
 export default class BXO {
   private _routes: Route[] = [];
+  private _wsRoutes: WSRoute[] = [];
   private plugins: BXO[] = [];
   private hooks: LifecycleHooks = {};
   private server?: any;
   private isRunning: boolean = false;
-  private hotReloadEnabled: boolean = false;
-  private watchedFiles: Set<string> = new Set();
-  private watchedExclude: Set<string> = new Set();
+  private serverPort?: number;
+  private serverHostname?: string;
 
   constructor() { }
 
   // Lifecycle hook methods
-  onBeforeStart(handler: () => Promise<void> | void): this {
+  onBeforeStart(handler: (instance: BXO) => Promise<void> | void): this {
     this.hooks.onBeforeStart = handler;
     return this;
   }
 
-  onAfterStart(handler: () => Promise<void> | void): this {
+  onAfterStart(handler: (instance: BXO) => Promise<void> | void): this {
     this.hooks.onAfterStart = handler;
     return this;
   }
 
-  onBeforeStop(handler: () => Promise<void> | void): this {
+  onBeforeStop(handler: (instance: BXO) => Promise<void> | void): this {
     this.hooks.onBeforeStop = handler;
     return this;
   }
 
-  onAfterStop(handler: () => Promise<void> | void): this {
+  onAfterStop(handler: (instance: BXO) => Promise<void> | void): this {
     this.hooks.onAfterStop = handler;
     return this;
   }
 
-  onBeforeRestart(handler: () => Promise<void> | void): this {
-    this.hooks.onBeforeRestart = handler;
-    return this;
-  }
 
-  onAfterRestart(handler: () => Promise<void> | void): this {
-    this.hooks.onAfterRestart = handler;
-    return this;
-  }
 
-  onRequest(handler: (ctx: Context) => Promise<void> | void): this {
+  onRequest(handler: (ctx: Context, instance: BXO) => Promise<void> | void): this {
     this.hooks.onRequest = handler;
     return this;
   }
 
-  onResponse(handler: (ctx: Context, response: any) => Promise<any> | any): this {
+  onResponse(handler: (ctx: Context, response: any, instance: BXO) => Promise<any> | any): this {
     this.hooks.onResponse = handler;
     return this;
   }
 
-  onError(handler: (ctx: Context, error: Error) => Promise<any> | any): this {
+  onError(handler: (ctx: Context, error: Error, instance: BXO) => Promise<any> | any): this {
     this.hooks.onError = handler;
     return this;
   }
@@ -207,24 +223,135 @@ export default class BXO {
     return this;
   }
 
+  // WebSocket route handler
+  ws(path: string, handler: WebSocketHandler): this {
+    this._wsRoutes.push({ path, handler });
+    return this;
+  }
+
+  // Helper methods to get all routes including plugin routes
+  private getAllRoutes(): Route[] {
+    const allRoutes = [...this._routes];
+    for (const plugin of this.plugins) {
+      allRoutes.push(...plugin._routes);
+    }
+    return allRoutes;
+  }
+
+  private getAllWSRoutes(): WSRoute[] {
+    const allWSRoutes = [...this._wsRoutes];
+    for (const plugin of this.plugins) {
+      allWSRoutes.push(...plugin._wsRoutes);
+    }
+    return allWSRoutes;
+  }
+
   // Route matching utility
   private matchRoute(method: string, pathname: string): { route: Route; params: Record<string, string> } | null {
-    for (const route of this._routes) {
+    const allRoutes = this.getAllRoutes();
+
+    for (const route of allRoutes) {
       if (route.method !== method) continue;
 
       const routeSegments = route.path.split('/').filter(Boolean);
       const pathSegments = pathname.split('/').filter(Boolean);
 
-      if (routeSegments.length !== pathSegments.length) continue;
+      const params: Record<string, string> = {};
+      let isMatch = true;
+
+      // Handle wildcard at the end (catch-all)
+      const hasWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '*';
+
+      if (hasWildcardAtEnd) {
+        // For catch-all wildcard, path must have at least as many segments as route (minus the wildcard)
+        if (pathSegments.length < routeSegments.length - 1) continue;
+      } else {
+        // For exact matching (with possible single-segment wildcards), lengths must match
+        if (routeSegments.length !== pathSegments.length) continue;
+      }
+
+      for (let i = 0; i < routeSegments.length; i++) {
+        const routeSegment = routeSegments[i];
+        const pathSegment = pathSegments[i];
+
+        if (!routeSegment) {
+          isMatch = false;
+          break;
+        }
+
+        // Handle catch-all wildcard at the end
+        if (routeSegment === '*' && i === routeSegments.length - 1) {
+          // Wildcard at end matches remaining path segments
+          const remainingPath = pathSegments.slice(i).join('/');
+          params['*'] = remainingPath;
+          break;
+        }
+
+        if (!pathSegment) {
+          isMatch = false;
+          break;
+        }
+
+        if (routeSegment.startsWith(':')) {
+          const paramName = routeSegment.slice(1);
+          params[paramName] = decodeURIComponent(pathSegment);
+        } else if (routeSegment === '*') {
+          // Single segment wildcard
+          params['*'] = decodeURIComponent(pathSegment);
+        } else if (routeSegment !== pathSegment) {
+          isMatch = false;
+          break;
+        }
+      }
+
+      if (isMatch) {
+        return { route, params };
+      }
+    }
+
+    return null;
+  }
+
+  // WebSocket route matching utility
+  private matchWSRoute(pathname: string): { route: WSRoute; params: Record<string, string> } | null {
+    const allWSRoutes = this.getAllWSRoutes();
+
+    for (const route of allWSRoutes) {
+      const routeSegments = route.path.split('/').filter(Boolean);
+      const pathSegments = pathname.split('/').filter(Boolean);
 
       const params: Record<string, string> = {};
       let isMatch = true;
 
+      // Handle wildcard at the end (catch-all)
+      const hasWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '*';
+
+      if (hasWildcardAtEnd) {
+        // For catch-all wildcard, path must have at least as many segments as route (minus the wildcard)
+        if (pathSegments.length < routeSegments.length - 1) continue;
+      } else {
+        // For exact matching (with possible single-segment wildcards), lengths must match
+        if (routeSegments.length !== pathSegments.length) continue;
+      }
+
       for (let i = 0; i < routeSegments.length; i++) {
         const routeSegment = routeSegments[i];
         const pathSegment = pathSegments[i];
 
-        if (!routeSegment || !pathSegment) {
+        if (!routeSegment) {
+          isMatch = false;
+          break;
+        }
+
+        // Handle catch-all wildcard at the end
+        if (routeSegment === '*' && i === routeSegments.length - 1) {
+          // Wildcard at end matches remaining path segments
+          const remainingPath = pathSegments.slice(i).join('/');
+          params['*'] = remainingPath;
+          break;
+        }
+
+        if (!pathSegment) {
           isMatch = false;
           break;
         }
@@ -232,6 +359,9 @@ export default class BXO {
         if (routeSegment.startsWith(':')) {
           const paramName = routeSegment.slice(1);
           params[paramName] = decodeURIComponent(pathSegment);
+        } else if (routeSegment === '*') {
+          // Single segment wildcard
+          params['*'] = decodeURIComponent(pathSegment);
         } else if (routeSegment !== pathSegment) {
           isMatch = false;
           break;
@@ -271,11 +401,30 @@ export default class BXO {
   }
 
   // Main request handler
-  private async handleRequest(request: Request): Promise<Response> {
+  private async handleRequest(request: Request, server?: any): Promise<Response | undefined> {
     const url = new URL(request.url);
     const method = request.method;
     const pathname = url.pathname;
 
+    // Check for WebSocket upgrade
+    if (request.headers.get('upgrade') === 'websocket') {
+      const wsMatchResult = this.matchWSRoute(pathname);
+      if (wsMatchResult && server) {
+        const success = server.upgrade(request, {
+          data: {
+            handler: wsMatchResult.route.handler,
+            params: wsMatchResult.params,
+            pathname
+          }
+        });
+
+        if (success) {
+          return; // undefined response means upgrade was successful
+        }
+      }
+      return new Response('WebSocket upgrade failed', { status: 400 });
+    }
+
     const matchResult = this.matchRoute(method, pathname);
     if (!matchResult) {
       return new Response('Not Found', { status: 404 });
@@ -298,30 +447,76 @@ export default class BXO {
         const formData = await request.formData();
         body = Object.fromEntries(formData.entries());
       } else {
-        body = await request.text();
+        // Try to parse as JSON if it looks like JSON, otherwise treat as text
+        const textBody = await request.text();
+        try {
+          // Check if the text looks like JSON
+          if (textBody.trim().startsWith('{') || textBody.trim().startsWith('[')) {
+            body = JSON.parse(textBody);
+          } else {
+            body = textBody;
+          }
+        } catch {
+          body = textBody;
+        }
       }
     }
 
-    // Create context
-    const ctx: Context = {
-      params: route.config?.params ? this.validateData(route.config.params, params) : params,
-      query: route.config?.query ? this.validateData(route.config.query, query) : query,
-      body: route.config?.body ? this.validateData(route.config.body, body) : body,
-      headers: route.config?.headers ? this.validateData(route.config.headers, headers) : headers,
-      request,
-      set: {}
-    };
+    // Create context with validation
+    let ctx: Context;
+    try {
+      // Validate each part separately to get better error messages
+      const validatedParams = route.config?.params ? this.validateData(route.config.params, params) : params;
+      const validatedQuery = route.config?.query ? this.validateData(route.config.query, query) : query;
+      const validatedBody = route.config?.body ? this.validateData(route.config.body, body) : body;
+      const validatedHeaders = route.config?.headers ? this.validateData(route.config.headers, headers) : headers;
+      
+      ctx = {
+        params: validatedParams,
+        query: validatedQuery,
+        body: validatedBody,
+        headers: validatedHeaders,
+        path: pathname,
+        request,
+        set: {}
+      };
+    } catch (validationError) {
+      // Validation failed - return error response
+      
+      // Extract detailed validation errors from Zod
+      let validationDetails = undefined;
+      if (validationError instanceof Error) {
+        if ('errors' in validationError && Array.isArray(validationError.errors)) {
+          validationDetails = validationError.errors;
+        } else if ('issues' in validationError && Array.isArray(validationError.issues)) {
+          validationDetails = validationError.issues;
+        }
+      }
+      
+      // Create a clean error message
+      const errorMessage = validationDetails && validationDetails.length > 0 
+        ? `Validation failed for ${validationDetails.length} field(s)`
+        : 'Validation failed';
+      
+      return new Response(JSON.stringify({ 
+        error: errorMessage,
+        details: validationDetails
+      }), {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
 
     try {
       // Run global onRequest hook
       if (this.hooks.onRequest) {
-        await this.hooks.onRequest(ctx);
+        await this.hooks.onRequest(ctx, this);
       }
 
       // Run BXO instance onRequest hooks
       for (const bxoInstance of this.plugins) {
         if (bxoInstance.hooks.onRequest) {
-          await bxoInstance.hooks.onRequest(ctx);
+          await bxoInstance.hooks.onRequest(ctx, this);
         }
       }
 
@@ -330,24 +525,43 @@ export default class BXO {
 
       // Run global onResponse hook
       if (this.hooks.onResponse) {
-        response = await this.hooks.onResponse(ctx, response) || response;
+        response = await this.hooks.onResponse(ctx, response, this) || response;
       }
 
       // Run BXO instance onResponse hooks
       for (const bxoInstance of this.plugins) {
         if (bxoInstance.hooks.onResponse) {
-          response = await bxoInstance.hooks.onResponse(ctx, response) || response;
+          response = await bxoInstance.hooks.onResponse(ctx, response, this) || response;
         }
       }
 
       // Validate response against schema if provided
       if (route.config?.response && !(response instanceof Response)) {
         try {
+          console.log('response', response);
           response = this.validateData(route.config.response, response);
         } catch (validationError) {
           // Response validation failed
-          const errorMessage = validationError instanceof Error ? validationError.message : 'Response validation failed';
-          return new Response(JSON.stringify({ error: `Response validation error: ${errorMessage}` }), {
+          
+          // Extract detailed validation errors from Zod
+          let validationDetails = undefined;
+          if (validationError instanceof Error) {
+            if ('errors' in validationError && Array.isArray(validationError.errors)) {
+              validationDetails = validationError.errors;
+            } else if ('issues' in validationError && Array.isArray(validationError.issues)) {
+              validationDetails = validationError.issues;
+            }
+          }
+          
+          // Create a clean error message
+          const errorMessage = validationDetails && validationDetails.length > 0 
+            ? `Response validation failed for ${validationDetails.length} field(s)`
+            : 'Response validation failed';
+          
+          return new Response(JSON.stringify({ 
+            error: errorMessage,
+            details: validationDetails
+          }), {
             status: 500,
             headers: { 'Content-Type': 'application/json' }
           });
@@ -359,6 +573,35 @@ export default class BXO {
         return response;
       }
 
+      // Handle File response (like Elysia)
+      if (response instanceof File || (typeof Bun !== 'undefined' && response instanceof Bun.file('').constructor)) {
+        const file = response as File;
+        const responseInit: ResponseInit = {
+          status: ctx.set.status || 200,
+          headers: {
+            'Content-Type': file.type || 'application/octet-stream',
+            'Content-Length': file.size.toString(),
+            ...ctx.set.headers
+          }
+        };
+        return new Response(file, responseInit);
+      }
+
+      // Handle Bun.file() response
+      if (typeof response === 'object' && response && 'stream' in response && 'size' in response) {
+        const bunFile = response as any;
+        const responseInit: ResponseInit = {
+          status: ctx.set.status || 200,
+          headers: {
+            'Content-Type': bunFile.type || 'application/octet-stream',
+            'Content-Length': bunFile.size?.toString() || '',
+            ...ctx.set.headers,
+            ...(bunFile.headers || {}) // Support custom headers from file helper
+          }
+        };
+        return new Response(bunFile, responseInit);
+      }
+
       const responseInit: ResponseInit = {
         status: ctx.set.status || 200,
         headers: ctx.set.headers || {}
@@ -381,12 +624,12 @@ export default class BXO {
       let errorResponse: any;
 
       if (this.hooks.onError) {
-        errorResponse = await this.hooks.onError(ctx, error as Error);
+        errorResponse = await this.hooks.onError(ctx, error as Error, this);
       }
 
       for (const bxoInstance of this.plugins) {
         if (bxoInstance.hooks.onError) {
-          errorResponse = await bxoInstance.hooks.onError(ctx, error as Error) || errorResponse;
+          errorResponse = await bxoInstance.hooks.onError(ctx, error as Error, this) || errorResponse;
         }
       }
 
@@ -409,77 +652,7 @@ export default class BXO {
     }
   }
 
-  // Hot reload functionality
-  enableHotReload(watchPaths: string[] = ['./'], excludePatterns: string[] = []): this {
-    this.hotReloadEnabled = true;
-    watchPaths.forEach(path => this.watchedFiles.add(path));
-    excludePatterns.forEach(pattern => this.watchedExclude.add(pattern));
-    return this;
-  }
-
-  private shouldExcludeFile(filename: string): boolean {
-    for (const pattern of this.watchedExclude) {
-      // Handle exact match
-      if (pattern === filename) {
-        return true;
-      }
-      
-      // Handle directory patterns (e.g., "node_modules/", "dist/")
-      if (pattern.endsWith('/')) {
-        if (filename.startsWith(pattern) || filename.includes(`/${pattern}`)) {
-          return true;
-        }
-      }
-      
-      // Handle wildcard patterns (e.g., "*.log", "temp*")
-      if (pattern.includes('*')) {
-        const regex = new RegExp(pattern.replace(/\*/g, '.*'));
-        if (regex.test(filename)) {
-          return true;
-        }
-      }
-      
-      // Handle file extension patterns (e.g., ".log", ".tmp")
-      if (pattern.startsWith('.') && filename.endsWith(pattern)) {
-        return true;
-      }
-      
-      // Handle substring matches for directories
-      if (filename.includes(pattern)) {
-        return true;
-      }
-    }
-    
-    return false;
-  }
-
-  private async setupFileWatcher(port: number, hostname: string): Promise<void> {
-    if (!this.hotReloadEnabled) return;
 
-    const fs = require('fs');
-
-    for (const watchPath of this.watchedFiles) {
-      try {
-        fs.watch(watchPath, { recursive: true }, async (eventType: string, filename: string) => {
-          if (filename && (filename.endsWith('.ts') || filename.endsWith('.js'))) {
-            // Check if file should be excluded
-            if (this.shouldExcludeFile(filename)) {
-              return;
-            }
-            
-            console.log(`🔄 File changed: ${filename}, restarting server...`);
-            await this.restart(port, hostname);
-          }
-        });
-        console.log(`👀 Watching ${watchPath} for changes...`);
-        if (this.watchedExclude.size > 0) {
-          console.log(`🚫 Excluding patterns: ${Array.from(this.watchedExclude).join(', ')}`);
-        }
-      } catch (error) {
-        console.warn(`⚠️  Could not watch ${watchPath}:`, error);
-      }
-    }
-  }
 
   // Server management methods
   async start(port: number = 3000, hostname: string = 'localhost'): Promise<void> {
@@ -491,27 +664,49 @@ export default class BXO {
     try {
       // Before start hook
       if (this.hooks.onBeforeStart) {
-        await this.hooks.onBeforeStart();
+        await this.hooks.onBeforeStart(this);
       }
 
       this.server = Bun.serve({
         port,
         hostname,
-        fetch: (request) => this.handleRequest(request),
+        fetch: (request, server) => this.handleRequest(request, server),
+        websocket: {
+          message: (ws: any, message: any) => {
+            const handler = ws.data?.handler;
+            if (handler?.onMessage) {
+              handler.onMessage(ws, message);
+            }
+          },
+          open: (ws: any) => {
+            const handler = ws.data?.handler;
+            if (handler?.onOpen) {
+              handler.onOpen(ws);
+            }
+          },
+          close: (ws: any, code?: number, reason?: string) => {
+            const handler = ws.data?.handler;
+            if (handler?.onClose) {
+              handler.onClose(ws, code, reason);
+            }
+          }
+        }
       });
 
-      this.isRunning = true;
+      // Verify server was created successfully
+      if (!this.server) {
+        throw new Error('Failed to create server instance');
+      }
 
-      console.log(`🦊 BXO server running at http://${hostname}:${port}`);
+      this.isRunning = true;
+      this.serverPort = port;
+      this.serverHostname = hostname;
 
       // After start hook
       if (this.hooks.onAfterStart) {
-        await this.hooks.onAfterStart();
+        await this.hooks.onAfterStart(this);
       }
 
-      // Setup hot reload
-      await this.setupFileWatcher(port, hostname);
-
       // Handle graceful shutdown
       const shutdownHandler = async () => {
         await this.stop();
@@ -536,55 +731,49 @@ export default class BXO {
     try {
       // Before stop hook
       if (this.hooks.onBeforeStop) {
-        await this.hooks.onBeforeStop();
+        await this.hooks.onBeforeStop(this);
       }
 
       if (this.server) {
-        this.server.stop();
-        this.server = null;
+        try {
+          // Try to stop the server gracefully
+          if (typeof this.server.stop === 'function') {
+            this.server.stop();
+          } else {
+            console.warn('⚠️  Server stop method not available');
+          }
+        } catch (stopError) {
+          console.error('❌ Error calling server.stop():', stopError);
+        }
+        
+        // Clear the server reference
+        this.server = undefined;
       }
 
+      // Reset state regardless of server.stop() success
       this.isRunning = false;
-
-      console.log('🛑 BXO server stopped');
+      this.serverPort = undefined;
+      this.serverHostname = undefined;
 
       // After stop hook
       if (this.hooks.onAfterStop) {
-        await this.hooks.onAfterStop();
+        await this.hooks.onAfterStop(this);
       }
 
+      console.log('✅ Server stopped successfully');
+
     } catch (error) {
       console.error('❌ Error stopping server:', error);
+      // Even if there's an error, reset the state
+      this.isRunning = false;
+      this.server = undefined;
+      this.serverPort = undefined;
+      this.serverHostname = undefined;
       throw error;
     }
   }
 
-  async restart(port: number = 3000, hostname: string = 'localhost'): Promise<void> {
-    try {
-      // Before restart hook
-      if (this.hooks.onBeforeRestart) {
-        await this.hooks.onBeforeRestart();
-      }
-
-      console.log('🔄 Restarting BXO server...');
 
-      await this.stop();
-
-      // Small delay to ensure cleanup
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      await this.start(port, hostname);
-
-      // After restart hook
-      if (this.hooks.onAfterRestart) {
-        await this.hooks.onAfterRestart();
-      }
-
-    } catch (error) {
-      console.error('❌ Error restarting server:', error);
-      throw error;
-    }
-  }
 
   // Backward compatibility
   async listen(port: number = 3000, hostname: string = 'localhost'): Promise<void> {
@@ -593,51 +782,127 @@ export default class BXO {
 
   // Server status
   isServerRunning(): boolean {
-    return this.isRunning;
+    return this.isRunning && this.server !== undefined;
   }
 
-  getServerInfo(): { running: boolean; hotReload: boolean; watchedFiles: string[]; excludePatterns: string[] } {
+  getServerInfo(): { running: boolean } {
     return {
-      running: this.isRunning,
-      hotReload: this.hotReloadEnabled,
-      watchedFiles: Array.from(this.watchedFiles),
-      excludePatterns: Array.from(this.watchedExclude)
+      running: this.isRunning
     };
   }
 
   // Get server information (alias for getServerInfo)
   get info() {
+    // Calculate total routes including plugins
+    const totalRoutes = this._routes.length + this.plugins.reduce((total, plugin) => total + plugin._routes.length, 0);
+    const totalWsRoutes = this._wsRoutes.length + this.plugins.reduce((total, plugin) => total + plugin._wsRoutes.length, 0);
+
     return {
-      ...this.getServerInfo(),
-      totalRoutes: this._routes.length,
+      // Server status
+      running: this.isRunning,
+      server: this.server ? 'Bun' : null,
+
+      // Connection details
+      hostname: this.serverHostname,
+      port: this.serverPort,
+      url: this.isRunning && this.serverHostname && this.serverPort
+        ? `http://${this.serverHostname}:${this.serverPort}`
+        : null,
+
+      // Application statistics
+      totalRoutes,
+      totalWsRoutes,
       totalPlugins: this.plugins.length,
-      server: this.server ? 'Bun' : null
+
+      // System information
+      runtime: 'Bun',
+      version: typeof Bun !== 'undefined' ? Bun.version : 'unknown',
+      pid: process.pid,
+      uptime: this.isRunning ? process.uptime() : 0
     };
   }
 
   // Get all routes information
   get routes() {
-    return this._routes.map((route: Route) => ({
+    // Get routes from main instance
+    const mainRoutes = this._routes.map((route: Route) => ({
       method: route.method,
       path: route.path,
       hasConfig: !!route.config,
-      config: route.config ? {
-        hasParams: !!route.config.params,
-        hasQuery: !!route.config.query,
-        hasBody: !!route.config.body,
-        hasHeaders: !!route.config.headers,
-        hasResponse: !!route.config.response
-      } : null
+      config: route.config || null,
+      source: 'main' as const
     }));
+
+    // Get routes from all plugins
+    const pluginRoutes = this.plugins.flatMap((plugin, pluginIndex) =>
+      plugin._routes.map((route: Route) => ({
+        method: route.method,
+        path: route.path,
+        hasConfig: !!route.config,
+        config: route.config || null,
+        source: 'plugin' as const,
+        pluginIndex
+      }))
+    );
+
+    return [...mainRoutes, ...pluginRoutes];
   }
+
+  // Get all WebSocket routes information
+  get wsRoutes() {
+    // Get WebSocket routes from main instance
+    const mainWsRoutes = this._wsRoutes.map((route: WSRoute) => ({
+      path: route.path,
+      hasHandlers: {
+        onOpen: !!route.handler.onOpen,
+        onMessage: !!route.handler.onMessage,
+        onClose: !!route.handler.onClose,
+        onError: !!route.handler.onError
+      },
+      source: 'main' as const
+    }));
+
+    // Get WebSocket routes from all plugins
+    const pluginWsRoutes = this.plugins.flatMap((plugin, pluginIndex) =>
+      plugin._wsRoutes.map((route: WSRoute) => ({
+        path: route.path,
+        hasHandlers: {
+          onOpen: !!route.handler.onOpen,
+          onMessage: !!route.handler.onMessage,
+          onClose: !!route.handler.onClose,
+          onError: !!route.handler.onError
+        },
+        source: 'plugin' as const,
+        pluginIndex
+      }))
+    );
+
+    return [...mainWsRoutes, ...pluginWsRoutes];
+  }
+}
+
+const error = (error: Error | string, status: number = 500) => {
+  return new Response(JSON.stringify({ error: error instanceof Error ? error.message : error }), { status });
 }
 
-const error = (error: Error, status: number = 500) => {
-  return new Response(JSON.stringify({ error: error.message }), { status });
+// File helper function (like Elysia)
+const file = (path: string, options?: { type?: string; headers?: Record<string, string> }) => {
+  const bunFile = Bun.file(path);
+
+  if (options?.type) {
+    // Create a wrapper to override the MIME type
+    return {
+      ...bunFile,
+      type: options.type,
+      headers: options.headers
+    };
+  }
+
+  return bunFile;
 }
 
 // Export Zod for convenience
-export { z, error };
+export { z, error, file };
 
 // Export types for external use
-export type { RouteConfig, Handler };
+export type { RouteConfig, RouteDetail, Handler, WebSocketHandler, WSRoute };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bxo",
   "module": "index.ts",
-  "version": "0.0.5-dev.2",
+  "version": "0.0.5-dev.20",
   "description": "A simple and lightweight web framework for Bun",
   "type": "module",
   "devDependencies": {

package/plugins/auth.ts

@@ -1,119 +0,0 @@
-import BXO from '../index';
-
-interface AuthOptions {
-  type: 'jwt' | 'bearer' | 'apikey';
-  secret?: string;
-  header?: string;
-  verify?: (token: string, ctx: any) => Promise<any> | any;
-  exclude?: string[];
-}
-
-export function auth(options: AuthOptions): BXO {
-  const {
-    type,
-    secret,
-    header = 'authorization',
-    verify,
-    exclude = []
-  } = options;
-
-  const authInstance = new BXO();
-
-  authInstance.onRequest(async (ctx: any) => {
-    const url = new URL(ctx.request.url);
-    const pathname = url.pathname;
-    
-    // Skip auth for excluded paths
-    if (exclude.some(path => {
-      if (path.includes('*')) {
-        const regex = new RegExp(path.replace(/\*/g, '.*'));
-        return regex.test(pathname);
-      }
-      return pathname === path || pathname.startsWith(path);
-    })) {
-      return;
-    }
-
-    const authHeader = ctx.request.headers.get(header.toLowerCase());
-    
-    if (!authHeader) {
-      throw new Response(JSON.stringify({ error: 'Authorization header required' }), {
-        status: 401,
-        headers: { 'Content-Type': 'application/json' }
-      });
-    }
-
-    let token: string;
-    
-    if (type === 'jwt' || type === 'bearer') {
-      if (!authHeader.startsWith('Bearer ')) {
-        throw new Response(JSON.stringify({ error: 'Invalid authorization format. Use Bearer <token>' }), {
-          status: 401,
-          headers: { 'Content-Type': 'application/json' }
-        });
-      }
-      token = authHeader.slice(7);
-    } else if (type === 'apikey') {
-      token = authHeader;
-    } else {
-      token = authHeader;
-    }
-
-    try {
-      let user: any;
-      
-      if (verify) {
-        user = await verify(token, ctx);
-      } else if (type === 'jwt' && secret) {
-        // Simple JWT verification (in production, use a proper JWT library)
-        const [headerB64, payloadB64, signature] = token.split('.');
-        if (!headerB64 || !payloadB64 || !signature) {
-          throw new Error('Invalid JWT format');
-        }
-        
-        const payload = JSON.parse(atob(payloadB64));
-        
-        // Check expiration
-        if (payload.exp && Date.now() >= payload.exp * 1000) {
-          throw new Error('Token expired');
-        }
-        
-        user = payload;
-      } else {
-        user = { token };
-      }
-
-      // Attach user to context
-      ctx.user = user;
-      
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Invalid token';
-      throw new Response(JSON.stringify({ error: message }), {
-        status: 401,
-        headers: { 'Content-Type': 'application/json' }
-      });
-    }
-  });
-
-  return authInstance;
-}
-
-// Helper function for creating JWT tokens (simple implementation)
-export function createJWT(payload: any, secret: string, expiresIn: number = 3600): string {
-  const header = { alg: 'HS256', typ: 'JWT' };
-  const now = Math.floor(Date.now() / 1000);
-  
-  const jwtPayload = {
-    ...payload,
-    iat: now,
-    exp: now + expiresIn
-  };
-  
-  const headerB64 = btoa(JSON.stringify(header));
-  const payloadB64 = btoa(JSON.stringify(jwtPayload));
-  
-  // Simple signature (in production, use proper HMAC-SHA256)
-  const signature = btoa(`${headerB64}.${payloadB64}.${secret}`);
-  
-  return `${headerB64}.${payloadB64}.${signature}`;
-} 

package/plugins/logger.ts

@@ -1,109 +0,0 @@
-import BXO from '../index';
-
-interface LoggerOptions {
-  format?: 'simple' | 'detailed' | 'json';
-  includeBody?: boolean;
-  includeHeaders?: boolean;
-}
-
-export function logger(options: LoggerOptions = {}): BXO {
-  const {
-    format = 'simple',
-    includeBody = false,
-    includeHeaders = false
-  } = options;
-
-  const loggerInstance = new BXO();
-
-  loggerInstance.onRequest(async (ctx: any) => {
-    ctx._startTime = Date.now();
-    
-    if (format === 'json') {
-      const logData: any = {
-        timestamp: new Date().toISOString(),
-        method: ctx.request.method,
-        url: ctx.request.url,
-        type: 'request'
-      };
-      
-      if (includeHeaders) {
-        logData.headers = Object.fromEntries(ctx.request.headers.entries());
-      }
-      
-      if (includeBody && ctx.body) {
-        logData.body = ctx.body;
-      }
-      
-      console.log(JSON.stringify(logData));
-    } else if (format === 'detailed') {
-      console.log(`→ ${ctx.request.method} ${ctx.request.url}`);
-      if (includeHeaders) {
-        console.log('  Headers:', Object.fromEntries(ctx.request.headers.entries()));
-      }
-      if (includeBody && ctx.body) {
-        console.log('  Body:', ctx.body);
-      }
-    } else {
-      console.log(`→ ${ctx.request.method} ${ctx.request.url}`);
-    }
-  });
-
-  loggerInstance.onResponse(async (ctx: any, response: any) => {
-    const duration = Date.now() - (ctx._startTime || 0);
-    const status = ctx.set.status || 200;
-    
-    if (format === 'json') {
-      const logData: any = {
-        timestamp: new Date().toISOString(),
-        method: ctx.request.method,
-        url: ctx.request.url,
-        status,
-        duration: `${duration}ms`,
-        type: 'response'
-      };
-      
-      if (includeHeaders && ctx.set.headers) {
-        logData.responseHeaders = ctx.set.headers;
-      }
-      
-      if (includeBody && response) {
-        logData.response = response;
-      }
-      
-      console.log(JSON.stringify(logData));
-    } else if (format === 'detailed') {
-      console.log(`← ${ctx.request.method} ${ctx.request.url} ${status} ${duration}ms`);
-      if (includeHeaders && ctx.set.headers) {
-        console.log('  Response Headers:', ctx.set.headers);
-      }
-      if (includeBody && response) {
-        console.log('  Response:', response);
-      }
-    } else {
-      const statusColor = status >= 400 ? '\x1b[31m' : status >= 300 ? '\x1b[33m' : '\x1b[32m';
-      const resetColor = '\x1b[0m';
-      console.log(`← ${ctx.request.method} ${ctx.request.url} ${statusColor}${status}${resetColor} ${duration}ms`);
-    }
-    
-    return response;
-  });
-
-  loggerInstance.onError(async (ctx: any, error: Error) => {
-    const duration = Date.now() - (ctx._startTime || 0);
-    
-    if (format === 'json') {
-      console.log(JSON.stringify({
-        timestamp: new Date().toISOString(),
-        method: ctx.request.method,
-        url: ctx.request.url,
-        error: error.message,
-        duration: `${duration}ms`,
-        type: 'error'
-      }));
-    } else {
-      console.log(`✗ ${ctx.request.method} ${ctx.request.url} \x1b[31mERROR\x1b[0m ${duration}ms: ${error.message}`);
-    }
-  });
-
-  return loggerInstance;
-}