bxo 0.0.5-dev.4 → 0.0.5-dev.41

package/index.ts

@@ -3,6 +3,31 @@ import { z } from 'zod';
 // Type utilities for extracting types from Zod schemas
 type InferZodType<T> = T extends z.ZodType<infer U> ? U : never;
 
+// Response configuration types
+type ResponseSchema = z.ZodSchema<any>;
+type StatusResponseSchema = Record<number, ResponseSchema>;
+type ResponseConfig = ResponseSchema | StatusResponseSchema;
+
+// Type utility to extract response type from response config
+type InferResponseType<T> = T extends ResponseSchema 
+  ? InferZodType<T>
+  : T extends StatusResponseSchema 
+    ? { [K in keyof T]: InferZodType<T[K]> }[keyof T]
+    : never;
+
+// Cookie interface
+interface Cookie {
+  name: string;
+  value: string;
+  domain?: string;
+  path?: string;
+  expires?: Date;
+  maxAge?: number;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: 'Strict' | 'Lax' | 'None';
+}
+
 // OpenAPI detail information
 interface RouteDetail {
   summary?: string;
@@ -21,28 +46,54 @@ interface RouteConfig {
   query?: z.ZodSchema<any>;
   body?: z.ZodSchema<any>;
   headers?: z.ZodSchema<any>;
-  response?: z.ZodSchema<any>;
+  cookies?: z.ZodSchema<any>;
+  response?: ResponseConfig;
   detail?: RouteDetail;
 }
 
+// Helper type to extract status codes from response config
+type StatusCodes<T> = T extends Record<number, any> ? keyof T : never;
+
 // Context type that's fully typed based on the route configuration
 export type Context<TConfig extends RouteConfig = {}> = {
   params: TConfig['params'] extends z.ZodSchema<any> ? InferZodType<TConfig['params']> : Record<string, string>;
   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>;
+  cookies: TConfig['cookies'] extends z.ZodSchema<any> ? InferZodType<TConfig['cookies']> : Record<string, string>;
+  path: string;
   request: Request;
   set: {
     status?: number;
     headers?: Record<string, string>;
+    cookies?: Cookie[];
+    redirect?: { location: string; status?: number };
   };
-  // Extended properties that can be added by plugins
-  user?: any;
+  status: <T extends number>(
+    code: TConfig['response'] extends StatusResponseSchema 
+      ? StatusCodes<TConfig['response']> | number
+      : T,
+    data?: TConfig['response'] extends StatusResponseSchema 
+      ? T extends keyof TConfig['response'] 
+        ? InferZodType<TConfig['response'][T]>
+        : any
+      : TConfig['response'] extends ResponseSchema 
+        ? InferZodType<TConfig['response']>
+        : any
+  ) => TConfig['response'] extends StatusResponseSchema 
+    ? T extends keyof TConfig['response'] 
+      ? InferZodType<TConfig['response'][T]>
+      : any
+    : TConfig['response'] extends ResponseSchema 
+      ? InferZodType<TConfig['response']>
+      : any;
+  redirect: (location: string, status?: number) => Response;
+  clearRedirect: () => void;
   [key: string]: any;
 };
 
-// Handler function type
-type Handler<TConfig extends RouteConfig = {}> = (ctx: Context<TConfig>) => Promise<any> | any;
+// Handler function type with proper response typing
+type Handler<TConfig extends RouteConfig = {}, EC = {}> = (ctx: Context<TConfig> & EC) => Promise<InferResponseType<TConfig['response']> | any> | InferResponseType<TConfig['response']> | any;
 
 // Route definition
 interface Route {
@@ -52,14 +103,39 @@ 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;
+  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;
+}
+
+// Add global options for BXO
+interface BXOOptions {
+  enableValidation?: boolean;
+}
+
+// Plugin interface for middleware-style plugins
+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;
@@ -67,67 +143,77 @@ interface LifecycleHooks {
 
 export default class BXO {
   private _routes: Route[] = [];
+  private _wsRoutes: WSRoute[] = [];
   private plugins: BXO[] = [];
-  private hooks: LifecycleHooks = {};
+  private middleware: Plugin[] = []; // New middleware array
+  private hooks: {
+    onBeforeStart?: (instance: BXO) => Promise<void> | void;
+    onAfterStart?: (instance: BXO) => Promise<void> | void;
+    onBeforeRestart?: (instance: BXO) => Promise<void> | void;
+    onAfterRestart?: (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;
+  } = {};
   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;
+  private enableValidation: boolean = true;
 
-  constructor() { }
+  constructor(options?: BXOOptions) {
+    this.enableValidation = options?.enableValidation ?? true;
+  }
 
   // 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;
   }
 
-  // Plugin system - now accepts other BXO instances
-  use(bxoInstance: BXO): this {
-    this.plugins.push(bxoInstance);
+  // Plugin system - now accepts both BXO instances and middleware plugins
+  use(plugin: BXO | Plugin): this {
+    if ('_routes' in plugin) {
+      // It's a BXO instance
+      this.plugins.push(plugin);
+    } else {
+      // It's a middleware plugin
+      this.middleware.push(plugin);
+    }
     return this;
   }
 
@@ -222,31 +308,301 @@ 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;
+
+      // Check for double wildcard (**) in the route
+      const hasDoubleWildcard = routeSegments.some(segment => segment === '**');
+      
+      // Handle double wildcard at the end (catch-all with slashes)
+      const hasDoubleWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '**';
+      
+      // Handle single wildcard at the end (catch-all)
+      const hasWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '*';
+
+      if (hasDoubleWildcardAtEnd) {
+        // For double wildcard at end, path must have at least as many segments as route (minus the double wildcard)
+        if (pathSegments.length < routeSegments.length - 1) continue;
+      } else if (hasWildcardAtEnd) {
+        // For single wildcard at end, path must have at least as many segments as route (minus the wildcard)
+        if (pathSegments.length < routeSegments.length - 1) continue;
+      } else if (!hasDoubleWildcard) {
+        // 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 double wildcard at the end (matches everything including slashes)
+        if (routeSegment === '**' && i === routeSegments.length - 1) {
+          const remainingPath = pathSegments.slice(i).join('/');
+          params['**'] = remainingPath;
+          break;
+        }
+
+        // Handle single wildcard at the end (catch-all)
+        if (routeSegment === '*' && i === routeSegments.length - 1) {
+          // Wildcard at end matches remaining path segments
+          const remainingPath = pathSegments.slice(i).join('/');
+          params['*'] = remainingPath;
+          break;
+        }
+
+        // Handle double wildcard in the middle (matches everything including slashes)
+        if (routeSegment === '**') {
+          // Find the next non-wildcard segment to match against
+          let nextNonWildcardIndex = i + 1;
+          while (nextNonWildcardIndex < routeSegments.length && 
+                 (routeSegments[nextNonWildcardIndex] === '*' || routeSegments[nextNonWildcardIndex] === '**')) {
+            nextNonWildcardIndex++;
+          }
+          
+          if (nextNonWildcardIndex >= routeSegments.length) {
+            // Double wildcard is at the end or followed by other wildcards
+            const remainingPath = pathSegments.slice(i).join('/');
+            params['**'] = remainingPath;
+            break;
+          }
+          
+          // Find the next matching segment in the path
+          const nextRouteSegment = routeSegments[nextNonWildcardIndex];
+          if (!nextRouteSegment) {
+            isMatch = false;
+            break;
+          }
+          
+          let foundMatch = false;
+          let matchedPath = '';
+          
+          for (let j = i; j < pathSegments.length; j++) {
+            const currentPathSegment = pathSegments[j];
+            
+            // Check if this path segment matches the next route segment
+            if (nextRouteSegment.startsWith(':')) {
+              // Param segment - always matches
+              matchedPath = pathSegments.slice(i, j).join('/');
+              params['**'] = matchedPath;
+              i = j - 1; // Adjust index for the next iteration
+              foundMatch = true;
+              break;
+            } else if (nextRouteSegment === '*') {
+              // Single wildcard - always matches
+              matchedPath = pathSegments.slice(i, j).join('/');
+              params['**'] = matchedPath;
+              i = j - 1; // Adjust index for the next iteration
+              foundMatch = true;
+              break;
+            } else if (nextRouteSegment === currentPathSegment) {
+              // Exact match
+              matchedPath = pathSegments.slice(i, j).join('/');
+              params['**'] = matchedPath;
+              i = j - 1; // Adjust index for the next iteration
+              foundMatch = true;
+              break;
+            }
+          }
+          
+          if (!foundMatch) {
+            isMatch = false;
+            break;
+          }
+          
+          continue;
+        }
+
+        if (!pathSegment) {
+          isMatch = false;
+          break;
+        }
+
+        if (routeSegment.startsWith(':')) {
+          const paramName = routeSegment.slice(1);
+          params[paramName] = pathSegment;
+        } else if (routeSegment === '*') {
+          // Single segment wildcard
+          params['*'] = 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;
 
+      // Check for double wildcard (**) in the route
+      const hasDoubleWildcard = routeSegments.some(segment => segment === '**');
+      
+      // Handle double wildcard at the end (catch-all with slashes)
+      const hasDoubleWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '**';
+      
+      // Handle single wildcard at the end (catch-all)
+      const hasWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '*';
+
+      if (hasDoubleWildcardAtEnd) {
+        // For double wildcard at end, path must have at least as many segments as route (minus the double wildcard)
+        if (pathSegments.length < routeSegments.length - 1) continue;
+      } else if (hasWildcardAtEnd) {
+        // For single wildcard at end, path must have at least as many segments as route (minus the wildcard)
+        if (pathSegments.length < routeSegments.length - 1) continue;
+      } else if (!hasDoubleWildcard) {
+        // 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 double wildcard at the end (matches everything including slashes)
+        if (routeSegment === '**' && i === routeSegments.length - 1) {
+          const remainingPath = pathSegments.slice(i).join('/');
+          params['**'] = remainingPath;
+          break;
+        }
+
+        // Handle single wildcard at the end (catch-all)
+        if (routeSegment === '*' && i === routeSegments.length - 1) {
+          // Wildcard at end matches remaining path segments
+          const remainingPath = pathSegments.slice(i).join('/');
+          params['*'] = remainingPath;
+          break;
+        }
+
+        // Handle double wildcard in the middle (matches everything including slashes)
+        if (routeSegment === '**') {
+          // Find the next non-wildcard segment to match against
+          let nextNonWildcardIndex = i + 1;
+          while (nextNonWildcardIndex < routeSegments.length && 
+                 (routeSegments[nextNonWildcardIndex] === '*' || routeSegments[nextNonWildcardIndex] === '**')) {
+            nextNonWildcardIndex++;
+          }
+          
+          if (nextNonWildcardIndex >= routeSegments.length) {
+            // Double wildcard is at the end or followed by other wildcards
+            const remainingPath = pathSegments.slice(i).join('/');
+            params['**'] = remainingPath;
+            break;
+          }
+          
+          // Find the next matching segment in the path
+          const nextRouteSegment = routeSegments[nextNonWildcardIndex];
+          if (!nextRouteSegment) {
+            isMatch = false;
+            break;
+          }
+          
+          let foundMatch = false;
+          let matchedPath = '';
+          
+          for (let j = i; j < pathSegments.length; j++) {
+            const currentPathSegment = pathSegments[j];
+            
+            // Check if this path segment matches the next route segment
+            if (nextRouteSegment.startsWith(':')) {
+              // Param segment - always matches
+              matchedPath = pathSegments.slice(i, j).join('/');
+              params['**'] = matchedPath;
+              i = j - 1; // Adjust index for the next iteration
+              foundMatch = true;
+              break;
+            } else if (nextRouteSegment === '*') {
+              // Single wildcard - always matches
+              matchedPath = pathSegments.slice(i, j).join('/');
+              params['**'] = matchedPath;
+              i = j - 1; // Adjust index for the next iteration
+              foundMatch = true;
+              break;
+            } else if (nextRouteSegment === currentPathSegment) {
+              // Exact match
+              matchedPath = pathSegments.slice(i, j).join('/');
+              params['**'] = matchedPath;
+              i = j - 1; // Adjust index for the next iteration
+              foundMatch = true;
+              break;
+            }
+          }
+          
+          if (!foundMatch) {
+            isMatch = false;
+            break;
+          }
+          
+          continue;
+        }
+
+        if (!pathSegment) {
           isMatch = false;
           break;
         }
 
         if (routeSegment.startsWith(':')) {
           const paramName = routeSegment.slice(1);
-          params[paramName] = decodeURIComponent(pathSegment);
+          params[paramName] = pathSegment;
+        } else if (routeSegment === '*') {
+          // Single segment wildcard
+          params['*'] = pathSegment;
         } else if (routeSegment !== pathSegment) {
           isMatch = false;
           break;
@@ -264,32 +620,106 @@ export default class BXO {
   // Parse query string
   private parseQuery(searchParams: URLSearchParams): Record<string, string | undefined> {
     const query: Record<string, string | undefined> = {};
-    for (const [key, value] of searchParams.entries()) {
+    searchParams.forEach((value, key) => {
       query[key] = value;
-    }
+    });
     return query;
   }
 
   // Parse headers
   private parseHeaders(headers: Headers): Record<string, string> {
     const headerObj: Record<string, string> = {};
-    for (const [key, value] of headers.entries()) {
+    headers.forEach((value, key) => {
       headerObj[key] = value;
-    }
+    });
     return headerObj;
   }
 
+  // Parse cookies from Cookie header
+  private parseCookies(cookieHeader: string | null): Record<string, string> {
+    const cookies: Record<string, string> = {};
+    
+    if (!cookieHeader) return cookies;
+    
+    const cookiePairs = cookieHeader.split(';');
+    for (const pair of cookiePairs) {
+      const [name, value] = pair.trim().split('=');
+      if (name && value) {
+        cookies[decodeURIComponent(name)] = decodeURIComponent(value);
+      }
+    }
+    
+    return cookies;
+  }
+
   // Validate data against Zod schema
   private validateData<T>(schema: z.ZodSchema<T> | undefined, data: any): T {
     if (!schema) return data;
     return schema.parse(data);
   }
 
+  // Validate response against response config (supports both simple and status-based schemas)
+  private validateResponse(responseConfig: ResponseConfig | undefined, data: any, status: number = 200): any {
+    if (!responseConfig || !this.enableValidation) return data;
+    
+    // If it's a simple schema (not status-based)
+    if ('parse' in responseConfig && typeof responseConfig.parse === 'function') {
+      return responseConfig.parse(data);
+    }
+    
+    // If it's a status-based schema
+    if (typeof responseConfig === 'object' && !('parse' in responseConfig)) {
+      const statusSchema = responseConfig[status];
+      if (statusSchema) {
+        return statusSchema.parse(data);
+      }
+      
+      // If no specific status schema found, try to find a fallback
+      // Common fallback statuses: 200, 201, 400, 500
+      const fallbackStatuses = [200, 201, 400, 500];
+      for (const fallbackStatus of fallbackStatuses) {
+        if (responseConfig[fallbackStatus]) {
+          return responseConfig[fallbackStatus]?.parse(data);
+        }
+      }
+      
+      // If no schema found for the status, return data as-is
+      return data;
+    }
+    
+    return data;
+  }
+
   // 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;
+    const rawPathname = url.pathname;
+    let pathname: string;
+    try {
+      pathname = decodeURI(rawPathname);
+    } catch {
+      pathname = rawPathname;
+    }
+
+    // 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) {
@@ -299,6 +729,7 @@ export default class BXO {
     const { route, params } = matchResult;
     const query = this.parseQuery(url.searchParams);
     const headers = this.parseHeaders(request.headers);
+    const cookies = this.parseCookies(request.headers.get('cookie'));
 
     let body: any;
     if (request.method !== 'GET' && request.method !== 'HEAD') {
@@ -313,56 +744,231 @@ 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 = this.enableValidation && route.config?.params ? this.validateData(route.config.params, params) : params;
+      const validatedQuery = this.enableValidation && route.config?.query ? this.validateData(route.config.query, query) : query;
+      const validatedBody = this.enableValidation && route.config?.body ? this.validateData(route.config.body, body) : body;
+      const validatedHeaders = this.enableValidation && route.config?.headers ? this.validateData(route.config.headers, headers) : headers;
+      const validatedCookies = this.enableValidation && route.config?.cookies ? this.validateData(route.config.cookies, cookies) : cookies;
+      
+      ctx = {
+        params: validatedParams,
+        query: validatedQuery,
+        body: validatedBody,
+        headers: validatedHeaders,
+        cookies: validatedCookies,
+        path: pathname,
+        request,
+        set: {},
+        status: ((code: number, data?: any) => {
+          ctx.set.status = code;
+          return data;
+        }) as any,
+                 redirect: ((location: string, status: number = 302) => {
+           // Record redirect intent only; avoid mutating generic status/headers so it can be canceled later
+           ctx.set.redirect = { location, status };
+
+           // Prepare headers for immediate Response return without persisting to ctx.set.headers
+           const responseHeaders: Record<string, string> = {
+             Location: location,
+             ...(ctx.set.headers || {})
+           };
+
+           // Handle cookies if any are set on context
+           if (ctx.set.cookies && ctx.set.cookies.length > 0) {
+             const cookieHeaders = ctx.set.cookies.map(cookie => {
+               let cookieString = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
+               if (cookie.domain) cookieString += `; Domain=${cookie.domain}`;
+               if (cookie.path) cookieString += `; Path=${cookie.path}`;
+               if (cookie.expires) cookieString += `; Expires=${cookie.expires.toUTCString()}`;
+               if (cookie.maxAge) cookieString += `; Max-Age=${cookie.maxAge}`;
+               if (cookie.secure) cookieString += `; Secure`;
+               if (cookie.httpOnly) cookieString += `; HttpOnly`;
+               if (cookie.sameSite) cookieString += `; SameSite=${cookie.sameSite}`;
+               return cookieString;
+             });
+             cookieHeaders.forEach((cookieHeader, index) => {
+               responseHeaders[index === 0 ? 'Set-Cookie' : `Set-Cookie-${index}`] = cookieHeader;
+             });
+           }
+
+           return new Response(null, {
+             status,
+             headers: responseHeaders
+           });
+         }) as any,
+        clearRedirect: (() => {
+          // Clear explicit redirect intent
+          delete ctx.set.redirect;
+          // Remove any Location header if present
+          if (ctx.set.headers) {
+            for (const key of Object.keys(ctx.set.headers)) {
+              if (key.toLowerCase() === 'location') {
+                delete ctx.set.headers[key];
+              }
+            }
+          }
+          // Reset status if it is a redirect
+          if (typeof ctx.set.status === 'number' && ctx.set.status >= 300 && ctx.set.status < 400) {
+            delete ctx.set.status;
+          }
+        }) as any
+      };
+    } 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 middleware onRequest hooks
+      for (const plugin of this.middleware) {
+        if (plugin.onRequest) {
+          await plugin.onRequest(ctx);
+        }
+      }
+
       // 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);
         }
       }
 
       // Execute route handler
       let response = await route.handler(ctx);
 
+      // Run middleware onResponse hooks
+      for (const plugin of this.middleware) {
+        if (plugin.onResponse) {
+          response = await plugin.onResponse(ctx, response) || response;
+        }
+      }
+
       // 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;
+        }
+      }
+
+      // If the handler did not return a response, but a redirect was configured via ctx.set,
+      // automatically create a redirect Response so users can call ctx.redirect(...) or set headers without returning.
+      const hasImplicitRedirectIntent = !!ctx.set.redirect 
+        || (typeof ctx.set.status === 'number' && ctx.set.status >= 300 && ctx.set.status < 400);
+      if ((response === undefined || response === null) && hasImplicitRedirectIntent) {
+        const locationFromHeaders = ctx.set.headers && Object.entries(ctx.set.headers).find(([k]) => k.toLowerCase() === 'location')?.[1];
+        const location = ctx.set.redirect?.location || locationFromHeaders;
+        if (location) {
+          // Build headers, ensuring Location is present
+          let responseHeaders: Record<string, string> = ctx.set.headers ? { ...ctx.set.headers } : {};
+          if (!Object.keys(responseHeaders).some(k => k.toLowerCase() === 'location')) {
+            responseHeaders['Location'] = location;
+          }
+          // Determine status precedence: redirect.status > set.status > 302
+          const status = ctx.set.redirect?.status ?? ctx.set.status ?? 302;
+
+          // Handle cookies if any are set
+          if (ctx.set.cookies && ctx.set.cookies.length > 0) {
+            const cookieHeaders = ctx.set.cookies.map(cookie => {
+              let cookieString = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
+              if (cookie.domain) cookieString += `; Domain=${cookie.domain}`;
+              if (cookie.path) cookieString += `; Path=${cookie.path}`;
+              if (cookie.expires) cookieString += `; Expires=${cookie.expires.toUTCString()}`;
+              if (cookie.maxAge) cookieString += `; Max-Age=${cookie.maxAge}`;
+              if (cookie.secure) cookieString += `; Secure`;
+              if (cookie.httpOnly) cookieString += `; HttpOnly`;
+              if (cookie.sameSite) cookieString += `; SameSite=${cookie.sameSite}`;
+              return cookieString;
+            });
+            cookieHeaders.forEach((cookieHeader, index) => {
+              responseHeaders[index === 0 ? 'Set-Cookie' : `Set-Cookie-${index}`] = cookieHeader;
+            });
+          }
+
+          return new Response(null, {
+            status,
+            headers: responseHeaders
+          });
         }
       }
 
       // Validate response against schema if provided
-      if (route.config?.response && !(response instanceof Response)) {
+      if (this.enableValidation && route.config?.response && !(response instanceof Response)) {
         try {
-          response = this.validateData(route.config.response, response);
+          const status = ctx.set.status || 200;
+          response = this.validateResponse(route.config.response, response, status);
         } 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' }
           });
@@ -374,9 +980,63 @@ 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);
+      }
+
+      // Prepare headers with cookies
+      let responseHeaders = ctx.set.headers ? { ...ctx.set.headers } : {};
+      
+      // Handle cookies if any are set
+      if (ctx.set.cookies && ctx.set.cookies.length > 0) {
+        const cookieHeaders = ctx.set.cookies.map(cookie => {
+          let cookieString = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
+          
+          if (cookie.domain) cookieString += `; Domain=${cookie.domain}`;
+          if (cookie.path) cookieString += `; Path=${cookie.path}`;
+          if (cookie.expires) cookieString += `; Expires=${cookie.expires.toUTCString()}`;
+          if (cookie.maxAge) cookieString += `; Max-Age=${cookie.maxAge}`;
+          if (cookie.secure) cookieString += `; Secure`;
+          if (cookie.httpOnly) cookieString += `; HttpOnly`;
+          if (cookie.sameSite) cookieString += `; SameSite=${cookie.sameSite}`;
+          
+          return cookieString;
+        });
+        
+        // Add Set-Cookie headers
+        cookieHeaders.forEach((cookieHeader, index) => {
+          responseHeaders[index === 0 ? 'Set-Cookie' : `Set-Cookie-${index}`] = cookieHeader;
+        });
+      }
+
       const responseInit: ResponseInit = {
         status: ctx.set.status || 200,
-        headers: ctx.set.headers || {}
+        headers: responseHeaders
       };
 
       if (typeof response === 'string') {
@@ -395,13 +1055,20 @@ export default class BXO {
       // Run error hooks
       let errorResponse: any;
 
+      // Run middleware onError hooks
+      for (const plugin of this.middleware) {
+        if (plugin.onError) {
+          errorResponse = await plugin.onError(ctx, error as Error) || errorResponse;
+        }
+      }
+
       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;
         }
       }
 
@@ -424,77 +1091,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> {
@@ -506,29 +1103,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);
+            }
+          }
+        }
       });
 
+      // Verify server was created successfully
+      if (!this.server) {
+        throw new Error('Failed to create server instance');
+      }
+
       this.isRunning = true;
       this.serverPort = port;
       this.serverHostname = hostname;
 
-      console.log(`🦊 BXO server running at http://${hostname}:${port}`);
-
       // 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();
@@ -553,57 +1170,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;
       this.serverPort = undefined;
       this.serverHostname = undefined;
 
-      console.log('🛑 BXO server stopped');
-
       // 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> {
@@ -612,41 +1221,38 @@ 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 {
       // 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,
+      totalRoutes,
+      totalWsRoutes,
       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',
@@ -657,21 +1263,104 @@ export default class BXO {
 
   // 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 || 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 });
+}
+
+// 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;
 }
 
-const error = (error: Error, status: number = 500) => {
-  return new Response(JSON.stringify({ error: error.message }), { status });
+// Redirect helper function (like Elysia)
+const redirect = (location: string, status: number = 302) => {
+  return new Response(null, {
+    status,
+    headers: { Location: location }
+  });
 }
 
 // Export Zod for convenience
-export { z, error };
+export { z, error, file, redirect };
 
 // Export types for external use
-export type { RouteConfig, RouteDetail, Handler };
+export type { RouteConfig, RouteDetail, Handler, WebSocketHandler, WSRoute, Cookie, BXOOptions };
+
+// Helper function to create a cookie
+export const createCookie = (
+  name: string,
+  value: string,
+  options: Omit<Cookie, 'name' | 'value'> = {}
+): Cookie => ({
+  name,
+  value,
+  ...options
+});