bxo 0.0.5-dev.4 → 0.0.5-dev.6

package/index.ts

@@ -52,6 +52,20 @@ 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;
@@ -67,6 +81,7 @@ interface LifecycleHooks {
 
 export default class BXO {
   private _routes: Route[] = [];
+  private _wsRoutes: WSRoute[] = [];
   private plugins: BXO[] = [];
   private hooks: LifecycleHooks = {};
   private server?: any;
@@ -222,6 +237,12 @@ export default class BXO {
     return this;
   }
 
+  // WebSocket route handler
+  ws(path: string, handler: WebSocketHandler): this {
+    this._wsRoutes.push({ path, handler });
+    return this;
+  }
+
   // Route matching utility
   private matchRoute(method: string, pathname: string): { route: Route; params: Record<string, string> } | null {
     for (const route of this._routes) {
@@ -261,6 +282,43 @@ export default class BXO {
     return null;
   }
 
+  // WebSocket route matching utility
+  private matchWSRoute(pathname: string): { route: WSRoute; params: Record<string, string> } | null {
+    for (const route of this._wsRoutes) {
+      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;
+
+      for (let i = 0; i < routeSegments.length; i++) {
+        const routeSegment = routeSegments[i];
+        const pathSegment = pathSegments[i];
+
+        if (!routeSegment || !pathSegment) {
+          isMatch = false;
+          break;
+        }
+
+        if (routeSegment.startsWith(':')) {
+          const paramName = routeSegment.slice(1);
+          params[paramName] = decodeURIComponent(pathSegment);
+        } else if (routeSegment !== pathSegment) {
+          isMatch = false;
+          break;
+        }
+      }
+
+      if (isMatch) {
+        return { route, params };
+      }
+    }
+
+    return null;
+  }
+
   // Parse query string
   private parseQuery(searchParams: URLSearchParams): Record<string, string | undefined> {
     const query: Record<string, string | undefined> = {};
@@ -286,11 +344,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 });
@@ -438,14 +515,14 @@ export default class BXO {
       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, '.*'));
@@ -453,18 +530,18 @@ export default class BXO {
           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;
   }
 
@@ -481,7 +558,7 @@ export default class BXO {
             if (this.shouldExcludeFile(filename)) {
               return;
             }
-            
+
             console.log(`🔄 File changed: ${filename}, restarting server...`);
             await this.restart(port, hostname);
           }
@@ -512,7 +589,27 @@ export default class BXO {
       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;
@@ -630,23 +727,24 @@ export default class BXO {
       // 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}` 
+      url: this.isRunning && this.serverHostname && this.serverPort
+        ? `http://${this.serverHostname}:${this.serverPort}`
         : null,
-      
+
       // Application statistics
       totalRoutes: this._routes.length,
+      totalWsRoutes: this._wsRoutes.length,
       totalPlugins: this.plugins.length,
-      
+
       // Hot reload configuration
       hotReload: this.hotReloadEnabled,
       watchedFiles: Array.from(this.watchedFiles),
       excludePatterns: Array.from(this.watchedExclude),
-      
+
       // System information
       runtime: 'Bun',
       version: typeof Bun !== 'undefined' ? Bun.version : 'unknown',
@@ -664,14 +762,27 @@ export default class BXO {
       config: route.config || null
     }));
   }
+
+  // Get all WebSocket routes information
+  get wsRoutes() {
+    return 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
+      }
+    }));
+  }
 }
 
-const error = (error: Error, status: number = 500) => {
-  return new Response(JSON.stringify({ error: error.message }), { status });
+const error = (error: Error | string, status: number = 500) => {
+  return new Response(JSON.stringify({ error: error instanceof Error ? error.message : error }), { status });
 }
 
 // Export Zod for convenience
 export { z, error };
 
 // Export types for external use
-export type { RouteConfig, RouteDetail, 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.4",
+  "version": "0.0.5-dev.6",
   "description": "A simple and lightweight web framework for Bun",
   "type": "module",
   "devDependencies": {