bxo 0.0.1 → 0.0.3

package/example.ts

@@ -4,31 +4,46 @@ import { cors, logger, auth, rateLimit, createJWT } from './plugins';
 // Create the app instance
 const app = new BXO();
 
+// Enable hot reload
+app.enableHotReload(['./']); // Watch current directory
+
 // Add plugins
 app
   .use(logger({ format: 'simple' }))
-  .use(cors({
+  .use(cors({ 
     origin: ['http://localhost:3000', 'https://example.com'],
-    credentials: true
+    credentials: true 
   }))
-  .use(rateLimit({
-    max: 100,
+  .use(rateLimit({ 
+    max: 100, 
     window: 60, // 1 minute
-    exclude: ['/health']
+    exclude: ['/health'] 
   }))
-  .use(auth({
-    type: 'jwt',
+  .use(auth({ 
+    type: 'jwt', 
     secret: 'your-secret-key',
     exclude: ['/', '/login', '/health']
   }));
 
-// Add lifecycle hooks
+// Add simplified lifecycle hooks
 app
-  .onStart(() => {
-    console.log('🚀 Server starting up...');
+  .onBeforeStart(() => {
+    console.log('🔧 Preparing to start server...');
+  })
+  .onAfterStart(() => {
+    console.log('✅ Server fully started and ready!');
+  })
+  .onBeforeStop(() => {
+    console.log('🔧 Preparing to stop server...');
+  })
+  .onAfterStop(() => {
+    console.log('✅ Server fully stopped!');
+  })
+  .onBeforeRestart(() => {
+    console.log('🔧 Preparing to restart server...');
   })
-  .onStop(() => {
-    console.log('🛑 Server shutting down...');
+  .onAfterRestart(() => {
+    console.log('✅ Server restart completed!');
   })
   .onRequest((ctx) => {
     console.log(`📨 Processing ${ctx.request.method} ${ctx.request.url}`);
@@ -48,7 +63,7 @@ app
   .get('/simple', async (ctx) => {
     return { message: 'Hello World' };
   })
-
+  
   // Three arguments: path, handler, config
   .get('/users/:id', async (ctx) => {
     // ctx.params.id is fully typed as string (UUID)
@@ -58,7 +73,7 @@ app
     params: z.object({ id: z.string().uuid() }),
     query: z.object({ include: z.string().optional() })
   })
-
+  
   .post('/users', async (ctx) => {
     // ctx.body is fully typed with name: string, email: string
     return { created: ctx.body };
@@ -71,18 +86,22 @@ app
 
   // Additional examples
   .get('/health', async (ctx) => {
-    return { status: 'ok', timestamp: new Date().toISOString() };
+    return { 
+      status: 'ok', 
+      timestamp: new Date().toISOString(),
+      server: app.getServerInfo()
+    };
   })
 
   .post('/login', async (ctx) => {
     const { username, password } = ctx.body;
-
+    
     // Simple auth check (in production, verify against database)
     if (username === 'admin' && password === 'password') {
       const token = createJWT({ username, role: 'admin' }, 'your-secret-key', 3600);
       return { token, user: { username, role: 'admin' } };
     }
-
+    
     ctx.set.status = 401;
     return { error: 'Invalid credentials' };
   }, {
@@ -97,9 +116,24 @@ app
     return { message: 'This is protected', user: ctx.user };
   })
 
-  .put('/users/:id', async (ctx) => {
+  // 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 {
-      updated: ctx.body,
+      ...app.getServerInfo(),
+      uptime: process.uptime(),
+      memory: process.memoryUsage()
+    };
+  })
+
+  .put('/users/:id', async (ctx) => {
+    return { 
+      updated: ctx.body, 
       id: ctx.params.id,
       version: ctx.headers['if-match']
     };
@@ -121,17 +155,29 @@ app
     params: z.object({ id: z.string().uuid() })
   });
 
-// Start the server
-app.listen(3000, 'localhost');
+// Start the server (with hot reload enabled)
+app.start(3000, 'localhost');
 
 console.log(`
-🦊 BXO Framework Example
+🦊 BXO Framework with Hot Reload
 
-Try these endpoints:
+✨ 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
+
+🧪 Try these endpoints:
 - GET  /simple
 - GET  /users/123e4567-e89b-12d3-a456-426614174000?include=profile
 - POST /users (with JSON body: {"name": "John", "email": "john@example.com"})
-- GET  /health
+- GET  /health (shows server info)
 - 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)
+
+💡 Edit this file and save to see hot reload in action!
 `); 

package/index.ts

@@ -30,13 +30,7 @@ export type Context<TConfig extends RouteConfig = {}> = {
 // Handler function type
 type Handler<TConfig extends RouteConfig = {}> = (ctx: Context<TConfig>) => Promise<any> | any;
 
-// Plugin interface (also exported from plugins/index.ts)
-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;
-}
+// Note: Plugin interface moved to plugins/index.ts as PluginFactory type
 
 
 
@@ -50,8 +44,12 @@ interface Route {
 
 // Lifecycle hooks
 interface LifecycleHooks {
-  onStart?: () => Promise<void> | void;
-  onStop?: () => Promise<void> | void;
+  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;
@@ -59,19 +57,43 @@ interface LifecycleHooks {
 
 export default class BXO {
   private routes: Route[] = [];
-  private plugins: Plugin[] = [];
+  private plugins: BXO[] = [];
   private hooks: LifecycleHooks = {};
+  private server?: any;
+  private isRunning: boolean = false;
+  private hotReloadEnabled: boolean = false;
+  private watchedFiles: Set<string> = new Set();
 
-  constructor() {}
+  constructor() { }
 
   // Lifecycle hook methods
-  onStart(handler: () => Promise<void> | void): this {
-    this.hooks.onStart = handler;
+  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;
   }
 
-  onStop(handler: () => Promise<void> | void): this {
-    this.hooks.onStop = handler;
+  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;
   }
 
@@ -90,9 +112,9 @@ export default class BXO {
     return this;
   }
 
-  // Plugin system
-  use(plugin: Plugin): this {
-    this.plugins.push(plugin);
+  // Plugin system - now accepts other BXO instances
+  use(bxoInstance: BXO): this {
+    this.plugins.push(bxoInstance);
     return this;
   }
 
@@ -298,10 +320,10 @@ export default class BXO {
         await this.hooks.onRequest(ctx);
       }
 
-      // Run plugin onRequest hooks
-      for (const plugin of this.plugins) {
-        if (plugin.onRequest) {
-          await plugin.onRequest(ctx);
+      // Run BXO instance onRequest hooks
+      for (const bxoInstance of this.plugins) {
+        if (bxoInstance.hooks.onRequest) {
+          await bxoInstance.hooks.onRequest(ctx);
         }
       }
 
@@ -313,10 +335,10 @@ export default class BXO {
         response = await this.hooks.onResponse(ctx, response) || response;
       }
 
-      // Run plugin onResponse hooks
-      for (const plugin of this.plugins) {
-        if (plugin.onResponse) {
-          response = await plugin.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;
         }
       }
 
@@ -350,9 +372,9 @@ export default class BXO {
         errorResponse = await this.hooks.onError(ctx, error as Error);
       }
 
-      for (const plugin of this.plugins) {
-        if (plugin.onError) {
-          errorResponse = await plugin.onError(ctx, error as Error) || errorResponse;
+      for (const bxoInstance of this.plugins) {
+        if (bxoInstance.hooks.onError) {
+          errorResponse = await bxoInstance.hooks.onError(ctx, error as Error) || errorResponse;
         }
       }
 
@@ -375,35 +397,165 @@ export default class BXO {
     }
   }
 
-  // Start the server
-  async listen(port: number = 3000, hostname: string = 'localhost'): Promise<void> {
-    if (this.hooks.onStart) {
-      await this.hooks.onStart();
+  // Hot reload functionality
+  enableHotReload(watchPaths: string[] = ['./']): this {
+    this.hotReloadEnabled = true;
+    watchPaths.forEach(path => this.watchedFiles.add(path));
+    return this;
+  }
+
+  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'))) {
+            console.log(`🔄 File changed: ${filename}, restarting server...`);
+            await this.restart(port, hostname);
+          }
+        });
+        console.log(`👀 Watching ${watchPath} for changes...`);
+      } 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;
     }
 
-    const server = Bun.serve({
-      port,
-      hostname,
-      fetch: (request) => this.handleRequest(request),
-    });
+    try {
+      // Before start hook
+      if (this.hooks.onBeforeStart) {
+        await this.hooks.onBeforeStart();
+      }
 
-    console.log(`🦊 BXO server running at http://${hostname}:${port}`);
+      this.server = Bun.serve({
+        port,
+        hostname,
+        fetch: (request) => this.handleRequest(request),
+      });
 
-    // Handle graceful shutdown
-    process.on('SIGINT', async () => {
-      if (this.hooks.onStop) {
-        await this.hooks.onStop();
+      this.isRunning = true;
+
+      console.log(`🦊 BXO server running at http://${hostname}:${port}`);
+
+      // After start hook
+      if (this.hooks.onAfterStart) {
+        await this.hooks.onAfterStart();
       }
-      server.stop();
-      process.exit(0);
-    });
+
+      // 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;
+
+      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[] } {
+    return {
+      running: this.isRunning,
+      hotReload: this.hotReloadEnabled,
+      watchedFiles: Array.from(this.watchedFiles)
+    };
+  }
+}
+
+const error = (error: Error, status: number = 500) => {
+  return new Response(JSON.stringify({ error: error.message }), { status });
 }
 
 // Export Zod for convenience
-export { z };
+export { z, error };
 
-export type { Plugin } from './plugins';
+export type { PluginFactory } from './plugins';
 
 // Export types for external use
 export type { RouteConfig };

package/package.json

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

package/plugins/auth.ts

@@ -1,3 +1,5 @@
+import BXO from '../index';
+
 interface AuthOptions {
   type: 'jwt' | 'bearer' | 'apikey';
   secret?: string;
@@ -6,7 +8,7 @@ interface AuthOptions {
   exclude?: string[];
 }
 
-export function auth(options: AuthOptions) {
+export function auth(options: AuthOptions): BXO {
   const {
     type,
     secret,
@@ -15,84 +17,85 @@ export function auth(options: AuthOptions) {
     exclude = []
   } = options;
 
-  return {
-    name: 'auth',
-    onRequest: async (ctx: any) => {
-      const url = new URL(ctx.request.url);
-      const pathname = url.pathname;
-      
-      // Skip auth for excluded paths
-      if (exclude.some(path => {
-        if (path.includes('*')) {
-          const regex = new RegExp(path.replace(/\*/g, '.*'));
-          return regex.test(pathname);
-        }
-        return pathname === path || pathname.startsWith(path);
-      })) {
-        return;
+  const authInstance = new BXO();
+
+  authInstance.onRequest(async (ctx: any) => {
+    const url = new URL(ctx.request.url);
+    const pathname = url.pathname;
+    
+    // Skip auth for excluded paths
+    if (exclude.some(path => {
+      if (path.includes('*')) {
+        const regex = new RegExp(path.replace(/\*/g, '.*'));
+        return regex.test(pathname);
       }
+      return pathname === path || pathname.startsWith(path);
+    })) {
+      return;
+    }
 
-      const authHeader = ctx.request.headers.get(header.toLowerCase());
-      
-      if (!authHeader) {
-        throw new Response(JSON.stringify({ error: 'Authorization header required' }), {
+    const authHeader = ctx.request.headers.get(header.toLowerCase());
+    
+    if (!authHeader) {
+      throw new Response(JSON.stringify({ error: 'Authorization header required' }), {
+        status: 401,
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
+
+    let token: string;
+    
+    if (type === 'jwt' || type === 'bearer') {
+      if (!authHeader.startsWith('Bearer ')) {
+        throw new Response(JSON.stringify({ error: 'Invalid authorization format. Use Bearer <token>' }), {
           status: 401,
           headers: { 'Content-Type': 'application/json' }
         });
       }
+      token = authHeader.slice(7);
+    } else if (type === 'apikey') {
+      token = authHeader;
+    } else {
+      token = authHeader;
+    }
 
-      let token: string;
+    try {
+      let user: any;
       
-      if (type === 'jwt' || type === 'bearer') {
-        if (!authHeader.startsWith('Bearer ')) {
-          throw new Response(JSON.stringify({ error: 'Invalid authorization format. Use Bearer <token>' }), {
-            status: 401,
-            headers: { 'Content-Type': 'application/json' }
-          });
+      if (verify) {
+        user = await verify(token, ctx);
+      } else if (type === 'jwt' && secret) {
+        // Simple JWT verification (in production, use a proper JWT library)
+        const [headerB64, payloadB64, signature] = token.split('.');
+        if (!headerB64 || !payloadB64 || !signature) {
+          throw new Error('Invalid JWT format');
         }
-        token = authHeader.slice(7);
-      } else if (type === 'apikey') {
-        token = authHeader;
-      } else {
-        token = authHeader;
-      }
-
-      try {
-        let user: any;
         
-        if (verify) {
-          user = await verify(token, ctx);
-        } else if (type === 'jwt' && secret) {
-          // Simple JWT verification (in production, use a proper JWT library)
-          const [headerB64, payloadB64, signature] = token.split('.');
-          if (!headerB64 || !payloadB64 || !signature) {
-            throw new Error('Invalid JWT format');
-          }
-          
-          const payload = JSON.parse(atob(payloadB64));
-          
-          // Check expiration
-          if (payload.exp && Date.now() >= payload.exp * 1000) {
-            throw new Error('Token expired');
-          }
-          
-          user = payload;
-        } else {
-          user = { token };
+        const payload = JSON.parse(atob(payloadB64));
+        
+        // Check expiration
+        if (payload.exp && Date.now() >= payload.exp * 1000) {
+          throw new Error('Token expired');
         }
-
-        // Attach user to context
-        ctx.user = user;
         
-      } catch (error) {
-        const message = error instanceof Error ? error.message : 'Invalid token';
-        throw new Response(JSON.stringify({ error: message }), {
-          status: 401,
-          headers: { 'Content-Type': 'application/json' }
-        });
+        user = payload;
+      } else {
+        user = { token };
       }
+
+      // Attach user to context
+      ctx.user = user;
+      
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Invalid token';
+      throw new Response(JSON.stringify({ error: message }), {
+        status: 401,
+        headers: { 'Content-Type': 'application/json' }
+      });
     }
-  };
+  });
+
+  return authInstance;
 }
 
 // Helper function for creating JWT tokens (simple implementation)