bxo 0.0.5-dev.4 → 0.0.5-dev.5

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 });
@@ -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;
@@ -640,6 +737,7 @@ export default class BXO {
       
       // Application statistics
       totalRoutes: this._routes.length,
+      totalWsRoutes: this._wsRoutes.length,
       totalPlugins: this.plugins.length,
       
       // Hot reload configuration
@@ -664,6 +762,19 @@ 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) => {
@@ -674,4 +785,4 @@ const error = (error: Error, status: number = 500) => {
 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.5",
   "description": "A simple and lightweight web framework for Bun",
   "type": "module",
   "devDependencies": {