bxo 0.0.5-dev.10 → 0.0.5-dev.11

package/example.ts

@@ -5,7 +5,7 @@ import { cors, logger, auth, rateLimit, createJWT } from './plugins';
 const app = new BXO();
 
 // Enable hot reload
-app.enableHotReload(['./']); // Watch current directory
+app.enableHotReload([process.cwd(), './']); // Watch current directory
 
 // Add plugins
 app

package/index.ts

@@ -73,8 +73,6 @@ interface LifecycleHooks {
   onAfterStart?: (instance: BXO) => Promise<void> | void;
   onBeforeStop?: (instance: BXO) => Promise<void> | void;
   onAfterStop?: (instance: BXO) => Promise<void> | void;
-  onBeforeRestart?: (instance: BXO) => Promise<void> | void;
-  onAfterRestart?: (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;
@@ -87,9 +85,6 @@ export default class 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;
 
@@ -116,15 +111,7 @@ export default class BXO {
     return this;
   }
 
-  onBeforeRestart(handler: (instance: BXO) => Promise<void> | void): this {
-    this.hooks.onBeforeRestart = handler;
-    return this;
-  }
 
-  onAfterRestart(handler: (instance: BXO) => Promise<void> | void): this {
-    this.hooks.onAfterRestart = handler;
-    return this;
-  }
 
   onRequest(handler: (ctx: Context, instance: BXO) => Promise<void> | void): this {
     this.hooks.onRequest = handler;
@@ -582,77 +569,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> {
@@ -697,16 +614,11 @@ export default class BXO {
       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(this);
       }
 
-      // Setup hot reload
-      await this.setupFileWatcher(port, hostname);
-
       // Handle graceful shutdown
       const shutdownHandler = async () => {
         await this.stop();
@@ -743,8 +655,6 @@ export default class BXO {
       this.serverPort = undefined;
       this.serverHostname = undefined;
 
-      console.log('🛑 BXO server stopped');
-
       // After stop hook
       if (this.hooks.onAfterStop) {
         await this.hooks.onAfterStop(this);
@@ -756,32 +666,7 @@ export default class BXO {
     }
   }
 
-  async restart(port: number = 3000, hostname: string = 'localhost'): Promise<void> {
-    try {
-      // Before restart hook
-      if (this.hooks.onBeforeRestart) {
-        await this.hooks.onBeforeRestart(this);
-      }
-
-      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(this);
-      }
-
-    } catch (error) {
-      console.error('❌ Error restarting server:', error);
-      throw error;
-    }
-  }
 
   // Backward compatibility
   async listen(port: number = 3000, hostname: string = 'localhost'): Promise<void> {
@@ -793,17 +678,18 @@ export default class BXO {
     return this.isRunning;
   }
 
-  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,
@@ -817,15 +703,10 @@ export default class BXO {
         : null,
 
       // Application statistics
-      totalRoutes: this._routes.length,
-      totalWsRoutes: this._wsRoutes.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',
@@ -836,25 +717,60 @@ 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() {
-    return this._wsRoutes.map((route: WSRoute) => ({
+    // 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];
   }
 }
 

package/package.json

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