bxo 0.0.5-dev.37 → 0.0.5-dev.39

package/README.md

@@ -203,7 +203,7 @@ app.post('/api/users/:id', async (ctx) => {
 
 ## 🔌 Plugin System
 
-BXO has a powerful plugin system with lifecycle hooks. Plugins are separate modules imported from `./plugins`.
+BXO has a powerful plugin system with lifecycle hooks. Plugins can be either middleware-style plugins or full BXO instances. Middleware plugins are separate modules imported from `./plugins` and are executed in the order they are added.
 
 ### Available Plugins
 
@@ -275,6 +275,8 @@ app.use(rateLimit({
 
 ### Creating Custom Plugins
 
+#### Middleware-Style Plugins (Recommended)
+
 ```typescript
 const customPlugin = {
   name: 'custom',
@@ -295,6 +297,19 @@ const customPlugin = {
 app.use(customPlugin);
 ```
 
+#### Full BXO Instance Plugins
+
+You can also use full BXO instances as plugins, which will merge their routes and hooks:
+
+```typescript
+const pluginApp = new BXO();
+pluginApp.get('/plugin-route', async (ctx) => {
+  return { message: 'From plugin' };
+});
+
+app.use(pluginApp);
+```
+
 ## 🎣 Lifecycle Hooks
 
 BXO provides comprehensive lifecycle hooks with a consistent before/after pattern for both server and request lifecycle:

package/index.ts

@@ -133,11 +133,30 @@ 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;
+}
+
 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 serverPort?: number;
@@ -186,9 +205,15 @@ export default class BXO {
     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;
   }
 
@@ -654,7 +679,7 @@ export default class BXO {
       const fallbackStatuses = [200, 201, 400, 500];
       for (const fallbackStatus of fallbackStatuses) {
         if (responseConfig[fallbackStatus]) {
-          return responseConfig[fallbackStatus].parse(data);
+          return responseConfig[fallbackStatus]?.parse(data);
         }
       }
       
@@ -835,6 +860,13 @@ export default class BXO {
     }
 
     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, this);
@@ -850,6 +882,13 @@ export default class BXO {
       // 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, this) || response;
@@ -1016,6 +1055,13 @@ 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, this);
       }

package/package.json

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

package/plugins/cors.ts

@@ -8,7 +8,7 @@ interface CORSOptions {
   maxAge?: number;
 }
 
-export function cors(options: CORSOptions = {}): BXO {
+export function cors(options: CORSOptions = {}): any {
   const {
     origin = '*',
     methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
@@ -17,14 +17,46 @@ export function cors(options: CORSOptions = {}): BXO {
     maxAge = 86400
   } = options;
 
-  const corsInstance = new BXO();
+  return {
+    name: 'cors',
+    onRequest: async (ctx: any) => {
+      // Handle preflight OPTIONS request
+      if (ctx.request.method === 'OPTIONS') {
+        const headers: Record<string, string> = {};
 
-  corsInstance.onRequest(async (ctx: any) => {
-    // Handle preflight OPTIONS request
-    if (ctx.request.method === 'OPTIONS') {
+        // Handle origin
+        if (typeof origin === 'boolean') {
+          if (origin) {
+            headers['Access-Control-Allow-Origin'] = ctx.request.headers.get('origin') || '*';
+          }
+        } else if (typeof origin === 'string') {
+          headers['Access-Control-Allow-Origin'] = origin;
+        } else if (Array.isArray(origin)) {
+          const requestOrigin = ctx.request.headers.get('origin');
+          if (requestOrigin && origin.includes(requestOrigin)) {
+            headers['Access-Control-Allow-Origin'] = requestOrigin;
+          }
+        }
+
+        headers['Access-Control-Allow-Methods'] = methods.join(', ');
+        headers['Access-Control-Allow-Headers'] = allowedHeaders.join(', ');
+        
+        if (credentials) {
+          headers['Access-Control-Allow-Credentials'] = 'true';
+        }
+        
+        headers['Access-Control-Max-Age'] = maxAge.toString();
+
+        ctx.set.status = 204;
+        ctx.set.headers = { ...ctx.set.headers, ...headers };
+        
+        throw new Response(null, { status: 204, headers });
+      }
+    },
+    onResponse: async (ctx: any, response: any) => {
       const headers: Record<string, string> = {};
 
-      // Handle origin
+      // Handle origin for actual requests
       if (typeof origin === 'boolean') {
         if (origin) {
           headers['Access-Control-Allow-Origin'] = ctx.request.headers.get('origin') || '*';
@@ -38,46 +70,26 @@ export function cors(options: CORSOptions = {}): BXO {
         }
       }
 
-      headers['Access-Control-Allow-Methods'] = methods.join(', ');
-      headers['Access-Control-Allow-Headers'] = allowedHeaders.join(', ');
-      
       if (credentials) {
         headers['Access-Control-Allow-Credentials'] = 'true';
       }
-      
-      headers['Access-Control-Max-Age'] = maxAge.toString();
-
-      ctx.set.status = 204;
-      ctx.set.headers = { ...ctx.set.headers, ...headers };
-      
-      throw new Response(null, { status: 204, headers });
-    }
-  });
-
-  corsInstance.onResponse(async (ctx: any, response: any) => {
-    const headers: Record<string, string> = {};
 
-    // Handle origin for actual requests
-    if (typeof origin === 'boolean') {
-      if (origin) {
-        headers['Access-Control-Allow-Origin'] = ctx.request.headers.get('origin') || '*';
+      // If response is a Response object, add headers to it
+      if (response instanceof Response) {
+        const newHeaders = new Headers(response.headers);
+        Object.entries(headers).forEach(([key, value]) => {
+          newHeaders.set(key, value);
+        });
+        return new Response(response.body, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: newHeaders
+        });
       }
-    } else if (typeof origin === 'string') {
-      headers['Access-Control-Allow-Origin'] = origin;
-    } else if (Array.isArray(origin)) {
-      const requestOrigin = ctx.request.headers.get('origin');
-      if (requestOrigin && origin.includes(requestOrigin)) {
-        headers['Access-Control-Allow-Origin'] = requestOrigin;
-      }
-    }
 
-    if (credentials) {
-      headers['Access-Control-Allow-Credentials'] = 'true';
+      // Otherwise, set headers in context for the framework to handle
+      ctx.set.headers = { ...ctx.set.headers, ...headers };
+      return response;
     }
-
-    ctx.set.headers = { ...ctx.set.headers, ...headers };
-    return response;
-  });
-
-  return corsInstance;
+  };
 } 

package/plugins/ratelimit.ts

@@ -52,7 +52,7 @@ class RateLimitStore {
   }
 }
 
-export function rateLimit(options: RateLimitOptions): BXO {
+export function rateLimit(options: RateLimitOptions): any {
   const {
     max,
     window,
@@ -74,67 +74,63 @@ export function rateLimit(options: RateLimitOptions): BXO {
   // Cleanup expired entries every 5 minutes
   setInterval(() => store.cleanup(), 5 * 60 * 1000);
 
-  const rateLimitInstance = new BXO();
+  return {
+    name: 'rateLimit',
+    onRequest: async (ctx: any) => {
+      const url = new URL(ctx.request.url);
+      const pathname = url.pathname;
+      
+      // Skip rate limiting 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;
+      }
 
-  rateLimitInstance.onRequest(async (ctx: any) => {
-    const url = new URL(ctx.request.url);
-    const pathname = url.pathname;
-    
-    // Skip rate limiting for excluded paths
-    if (exclude.some(path => {
-      if (path.includes('*')) {
-        const regex = new RegExp(path.replace(/\*/g, '.*'));
-        return regex.test(pathname);
+      const key = keyGenerator(ctx);
+      const entry = store.increment(key, window);
+      
+      if (entry.count > max) {
+        const resetTime = Math.ceil(entry.resetTime / 1000);
+        throw new Response(JSON.stringify({ 
+          error: message,
+          retryAfter: resetTime
+        }), {
+          status: statusCode,
+          headers: {
+            'Content-Type': 'application/json',
+            'X-RateLimit-Limit': max.toString(),
+            'X-RateLimit-Remaining': '0',
+            'X-RateLimit-Reset': resetTime.toString(),
+            'Retry-After': resetTime.toString()
+          }
+        });
       }
-      return pathname === path || pathname.startsWith(path);
-    })) {
-      return;
-    }
 
-    const key = keyGenerator(ctx);
-    const entry = store.increment(key, window);
-    
-    if (entry.count > max) {
-      const resetTime = Math.ceil(entry.resetTime / 1000);
-      throw new Response(JSON.stringify({ 
-        error: message,
-        retryAfter: resetTime - Math.floor(Date.now() / 1000)
-      }), {
-        status: statusCode,
-        headers: { 
-          'Content-Type': 'application/json',
-          'X-RateLimit-Limit': max.toString(),
-          'X-RateLimit-Remaining': '0',
-          'X-RateLimit-Reset': resetTime.toString(),
-          'Retry-After': (resetTime - Math.floor(Date.now() / 1000)).toString()
-        }
-      });
-    }
-    
-    // Add rate limit headers
-    ctx.set.headers = {
-      ...ctx.set.headers,
-      'X-RateLimit-Limit': max.toString(),
-      'X-RateLimit-Remaining': Math.max(0, max - entry.count).toString(),
-      'X-RateLimit-Reset': Math.ceil(entry.resetTime / 1000).toString()
-    };
-  });
+      // Add rate limit headers to context
+      ctx.set.headers = {
+        ...ctx.set.headers,
+        'X-RateLimit-Limit': max.toString(),
+        'X-RateLimit-Remaining': Math.max(0, max - entry.count).toString(),
+        'X-RateLimit-Reset': Math.ceil(entry.resetTime / 1000).toString()
+      };
+    },
+    onResponse: async (ctx: any, response: any) => {
+      // Skip successful requests if configured
+      if (skipSuccessful && response instanceof Response && response.status < 400) {
+        return response;
+      }
 
-  rateLimitInstance.onResponse(async (ctx: any, response: any) => {
-    const status = ctx.set.status || 200;
-    const key = keyGenerator(ctx);
-    
-    // Optionally skip counting successful or failed requests
-    if ((skipSuccessful && status < 400) || (skipFailed && status >= 400)) {
-      // Decrement the counter since we don't want to count this request
-      const entry = store.get(key);
-      if (entry && entry.count > 0) {
-        store.set(key, entry.count - 1, entry.resetTime);
+      // Skip failed requests if configured
+      if (skipFailed && response instanceof Response && response.status >= 400) {
+        return response;
       }
-    }
-    
-    return response;
-  });
 
-  return rateLimitInstance;
+      return response;
+    }
+  };
 }