bxo 0.0.5-dev.9 → 0.0.6

package/index.ts

@@ -1,885 +0,0 @@
-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>;
-  query?: z.ZodSchema<any>;
-  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
-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>;
-  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;
-
-// Route definition
-interface Route {
-  method: string;
-  path: string;
-  handler: Handler<any>;
-  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;
-}
-
-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 {
-    this.hooks.onBeforeStart = handler;
-    return this;
-  }
-
-  onAfterStart(handler: () => Promise<void> | void): this {
-    this.hooks.onAfterStart = handler;
-    return this;
-  }
-
-  onBeforeStop(handler: () => Promise<void> | void): this {
-    this.hooks.onBeforeStop = handler;
-    return this;
-  }
-
-  onAfterStop(handler: () => 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 {
-    this.hooks.onRequest = handler;
-    return this;
-  }
-
-  onResponse(handler: (ctx: Context, response: any) => Promise<any> | any): this {
-    this.hooks.onResponse = handler;
-    return this;
-  }
-
-  onError(handler: (ctx: Context, error: Error) => 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);
-    return this;
-  }
-
-  // HTTP method handlers with overloads for type safety
-  get<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>
-  ): this;
-  get<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config: TConfig
-  ): this;
-  get<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config?: TConfig
-  ): this {
-    this._routes.push({ method: 'GET', path, handler, config });
-    return this;
-  }
-
-  post<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>
-  ): this;
-  post<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config: TConfig
-  ): this;
-  post<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config?: TConfig
-  ): this {
-    this._routes.push({ method: 'POST', path, handler, config });
-    return this;
-  }
-
-  put<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>
-  ): this;
-  put<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config: TConfig
-  ): this;
-  put<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config?: TConfig
-  ): this {
-    this._routes.push({ method: 'PUT', path, handler, config });
-    return this;
-  }
-
-  delete<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>
-  ): this;
-  delete<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config: TConfig
-  ): this;
-  delete<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config?: TConfig
-  ): this {
-    this._routes.push({ method: 'DELETE', path, handler, config });
-    return this;
-  }
-
-  patch<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>
-  ): this;
-  patch<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config: TConfig
-  ): this;
-  patch<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config?: TConfig
-  ): this {
-    this._routes.push({ method: 'PATCH', path, handler, config });
-    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) {
-      if (route.method !== method) continue;
-
-      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) {
-          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 {
-    for (const route of this._wsRoutes) {
-      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) {
-          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;
-  }
-
-  // Parse query string
-  private parseQuery(searchParams: URLSearchParams): Record<string, string | undefined> {
-    const query: Record<string, string | undefined> = {};
-    for (const [key, value] of searchParams.entries()) {
-      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()) {
-      headerObj[key] = value;
-    }
-    return headerObj;
-  }
-
-  // Validate data against Zod schema
-  private validateData<T>(schema: z.ZodSchema<T> | undefined, data: any): T {
-    if (!schema) return data;
-    return schema.parse(data);
-  }
-
-  // Main request handler
-  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 });
-    }
-
-    const { route, params } = matchResult;
-    const query = this.parseQuery(url.searchParams);
-    const headers = this.parseHeaders(request.headers);
-
-    let body: any;
-    if (request.method !== 'GET' && request.method !== 'HEAD') {
-      const contentType = request.headers.get('content-type');
-      if (contentType?.includes('application/json')) {
-        try {
-          body = await request.json();
-        } catch {
-          body = {};
-        }
-      } else if (contentType?.includes('application/x-www-form-urlencoded')) {
-        const formData = await request.formData();
-        body = Object.fromEntries(formData.entries());
-      } else {
-        body = await request.text();
-      }
-    }
-
-    // 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,
-      path: pathname,
-      request,
-      set: {}
-    };
-
-    try {
-      // Run global onRequest hook
-      if (this.hooks.onRequest) {
-        await this.hooks.onRequest(ctx);
-      }
-
-      // Run BXO instance onRequest hooks
-      for (const bxoInstance of this.plugins) {
-        if (bxoInstance.hooks.onRequest) {
-          await bxoInstance.hooks.onRequest(ctx);
-        }
-      }
-
-      // Execute route handler
-      let response = await route.handler(ctx);
-
-      // Run global onResponse hook
-      if (this.hooks.onResponse) {
-        response = await this.hooks.onResponse(ctx, response) || response;
-      }
-
-      // Run BXO instance onResponse hooks
-      for (const bxoInstance of this.plugins) {
-        if (bxoInstance.hooks.onResponse) {
-          response = await bxoInstance.hooks.onResponse(ctx, response) || response;
-        }
-      }
-
-      // Validate response against schema if provided
-      if (route.config?.response && !(response instanceof Response)) {
-        try {
-          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}` }), {
-            status: 500,
-            headers: { 'Content-Type': 'application/json' }
-          });
-        }
-      }
-
-      // Convert response to Response object
-      if (response instanceof Response) {
-        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 || {}
-      };
-
-      if (typeof response === 'string') {
-        return new Response(response, responseInit);
-      }
-
-      return new Response(JSON.stringify(response), {
-        ...responseInit,
-        headers: {
-          'Content-Type': 'application/json',
-          ...responseInit.headers
-        }
-      });
-
-    } catch (error) {
-      // Run error hooks
-      let errorResponse: any;
-
-      if (this.hooks.onError) {
-        errorResponse = await this.hooks.onError(ctx, error as Error);
-      }
-
-      for (const bxoInstance of this.plugins) {
-        if (bxoInstance.hooks.onError) {
-          errorResponse = await bxoInstance.hooks.onError(ctx, error as Error) || errorResponse;
-        }
-      }
-
-      if (errorResponse) {
-        if (errorResponse instanceof Response) {
-          return errorResponse;
-        }
-        return new Response(JSON.stringify(errorResponse), {
-          status: 500,
-          headers: { 'Content-Type': 'application/json' }
-        });
-      }
-
-      // Default error response
-      const errorMessage = error instanceof Error ? error.message : 'Internal Server Error';
-      return new Response(JSON.stringify({ error: errorMessage }), {
-        status: 500,
-        headers: { 'Content-Type': 'application/json' }
-      });
-    }
-  }
-
-  // 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> {
-    if (this.isRunning) {
-      console.log('⚠️  Server is already running');
-      return;
-    }
-
-    try {
-      // Before start hook
-      if (this.hooks.onBeforeStart) {
-        await this.hooks.onBeforeStart();
-      }
-
-      this.server = Bun.serve({
-        port,
-        hostname,
-        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;
-      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();
-      }
-
-      // Setup hot reload
-      await this.setupFileWatcher(port, hostname);
-
-      // Handle graceful shutdown
-      const shutdownHandler = async () => {
-        await this.stop();
-        process.exit(0);
-      };
-
-      process.on('SIGINT', shutdownHandler);
-      process.on('SIGTERM', shutdownHandler);
-
-    } catch (error) {
-      console.error('❌ Failed to start server:', error);
-      throw error;
-    }
-  }
-
-  async stop(): Promise<void> {
-    if (!this.isRunning) {
-      console.log('⚠️  Server is not running');
-      return;
-    }
-
-    try {
-      // Before stop hook
-      if (this.hooks.onBeforeStop) {
-        await this.hooks.onBeforeStop();
-      }
-
-      if (this.server) {
-        this.server.stop();
-        this.server = null;
-      }
-
-      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();
-      }
-
-    } catch (error) {
-      console.error('❌ Error stopping server:', error);
-      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> {
-    return this.start(port, hostname);
-  }
-
-  // Server status
-  isServerRunning(): boolean {
-    return this.isRunning;
-  }
-
-  getServerInfo(): { running: boolean; hotReload: boolean; watchedFiles: string[]; excludePatterns: string[] } {
-    return {
-      running: this.isRunning,
-      hotReload: this.hotReloadEnabled,
-      watchedFiles: Array.from(this.watchedFiles),
-      excludePatterns: Array.from(this.watchedExclude)
-    };
-  }
-
-  // Get server information (alias for getServerInfo)
-  get info() {
-    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}`
-        : 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',
-      pid: process.pid,
-      uptime: this.isRunning ? process.uptime() : 0
-    };
-  }
-
-  // Get all routes information
-  get routes() {
-    return this._routes.map((route: Route) => ({
-      method: route.method,
-      path: route.path,
-      hasConfig: !!route.config,
-      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 | 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;
-}
-
-// Export Zod for convenience
-export { z, error, file };
-
-// Export types for external use
-export type { RouteConfig, RouteDetail, Handler, WebSocketHandler, WSRoute };