bxo 0.0.5-dev.10 → 0.0.5-dev.12

package/example.ts

@@ -1,13 +1,39 @@
 import BXO, { z } from './index';
 import { cors, logger, auth, rateLimit, createJWT } from './plugins';
 
+// Create a simple API plugin that defines its own routes
+function createApiPlugin(): BXO {
+  const apiPlugin = new BXO();
+  
+  apiPlugin
+    .get('/api/info', async (ctx) => {
+      return { 
+        name: 'BXO API Plugin',
+        version: '1.0.0',
+        endpoints: ['/api/info', '/api/ping', '/api/time']
+      };
+    })
+    .get('/api/ping', async (ctx) => {
+      return { ping: 'pong', timestamp: Date.now() };
+    })
+    .get('/api/time', async (ctx) => {
+      return { time: new Date().toISOString() };
+    })
+    .post('/api/echo', async (ctx) => {
+      return { echo: ctx.body };
+    }, {
+      body: z.object({
+        message: z.string()
+      })
+    });
+    
+  return apiPlugin;
+}
+
 // Create the app instance
 const app = new BXO();
 
-// Enable hot reload
-app.enableHotReload(['./']); // Watch current directory
-
-// Add plugins
+// Add plugins (including our new API plugin)
 app
   .use(logger({ format: 'simple' }))
   .use(cors({ 
@@ -22,8 +48,9 @@ app
   .use(auth({ 
     type: 'jwt', 
     secret: 'your-secret-key',
-    exclude: ['/', '/login', '/health']
-  }));
+    exclude: ['/', '/login', '/health', '/api/*']
+  }))
+  .use(createApiPlugin()); // Add our plugin with actual routes
 
 // Add simplified lifecycle hooks
 app
@@ -39,12 +66,6 @@ app
   .onAfterStop(() => {
     console.log('✅ Server fully stopped!');
   })
-  .onBeforeRestart(() => {
-    console.log('🔧 Preparing to restart server...');
-  })
-  .onAfterRestart(() => {
-    console.log('✅ Server restart completed!');
-  })
   .onRequest((ctx) => {
     console.log(`📨 Processing ${ctx.request.method} ${ctx.request.url}`);
   })
@@ -116,13 +137,6 @@ app
     return { message: 'This is protected', user: ctx.user };
   })
 
-  // Server control endpoints
-  .post('/restart', async (ctx) => {
-    // Restart the server
-    setTimeout(() => app.restart(3000), 100);
-    return { message: 'Server restart initiated' };
-  })
-
   .get('/status', async (ctx) => {
     return {
       ...app.getServerInfo(),
@@ -162,12 +176,12 @@ console.log(`
 🦊 BXO Framework with Hot Reload
 
 ✨ Features Enabled:
-- 🔄 Hot reload (edit any .ts/.js file to restart)
 - 🎣 Full lifecycle hooks (before/after pattern)
 - 🔒 JWT authentication
 - 📊 Rate limiting  
 - 🌐 CORS support
 - 📝 Request logging
+- 🔌 API Plugin with routes
 
 🧪 Try these endpoints:
 - GET  /simple
@@ -177,7 +191,14 @@ console.log(`
 - POST /login (with JSON body: {"username": "admin", "password": "password"})
 - GET  /protected (requires Bearer token from /login)
 - GET  /status (server statistics)
-- POST /restart (restart server programmatically)
+
+🔌 API Plugin endpoints:
+- GET  /api/info (plugin information)
+- GET  /api/ping (ping pong)
+- GET  /api/time (current time)
+- POST /api/echo (echo message: {"message": "hello"})
 
 💡 Edit this file and save to see hot reload in action!
-`); 
+`); 
+
+console.log(app.routes)

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.12",
   "description": "A simple and lightweight web framework for Bun",
   "type": "module",
   "devDependencies": {