bxo 0.0.5-dev.44 → 0.0.5-dev.46

package/example.ts

@@ -0,0 +1,20 @@
+import BXO from ".";
+import { cors } from "./plugins";
+
+const app = new BXO();
+
+app.use(cors());
+
+app.get('/', (ctx) => {
+    return { message: 'Hello, world!' };
+});
+
+app.get("/api/actions/nodula.auth.login", (ctx) => {
+    return { message: 'Hello, world!' };
+});
+
+app.post("/api/actions/nodula.auth.login", (ctx) => {
+    return { message: 'Hello, world!' };
+});
+
+app.listen(3000);

package/index.ts

@@ -136,7 +136,7 @@ interface BXOOptions {
 // Plugin interface for middleware-style plugins
 interface Plugin {
   name?: string;
-  onRequest?: (ctx: Context) => Promise<void> | void;
+  onRequest?: (ctx: Context) => Promise<Response | void> | Response | void;
   onResponse?: (ctx: Context, response: any) => Promise<any> | any;
   onError?: (ctx: Context, error: Error) => Promise<any> | any;
 }
@@ -153,7 +153,7 @@ export default class BXO {
     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;
+    onRequest?: (ctx: Context, instance: BXO) => Promise<Response | void> | Response | void;
     onResponse?: (ctx: Context, response: any, instance: BXO) => Promise<any> | any;
     onError?: (ctx: Context, error: Error, instance: BXO) => Promise<any> | any;
   } = {};
@@ -721,6 +721,84 @@ export default class BXO {
       return new Response('WebSocket upgrade failed', { status: 400 });
     }
 
+    // Handle OPTIONS requests for CORS preflight before route matching
+    if (method === 'OPTIONS') {
+      // Create a minimal context for OPTIONS requests
+      const ctx: Context = {
+        params: {},
+        query: {},
+        body: {},
+        headers: this.parseHeaders(request.headers),
+        cookies: {},
+        path: pathname,
+        request,
+        set: {},
+        status: ((code: number, data?: any) => {
+          ctx.set.status = code;
+          return data;
+        }) as any,
+        redirect: ((location: string, status: number = 302) => {
+          ctx.set.redirect = { location, status };
+          const responseHeaders: Record<string, string> = {
+            Location: location,
+            ...(ctx.set.headers || {})
+          };
+          return new Response(null, {
+            status,
+            headers: responseHeaders
+          });
+        }) as any,
+        clearRedirect: (() => {
+          delete ctx.set.redirect;
+          if (ctx.set.headers) {
+            for (const key of Object.keys(ctx.set.headers)) {
+              if (key.toLowerCase() === 'location') {
+                delete ctx.set.headers[key];
+              }
+            }
+          }
+          if (typeof ctx.set.status === 'number' && ctx.set.status >= 300 && ctx.set.status < 400) {
+            delete ctx.set.status;
+          }
+        }) as any
+      };
+
+      // Run middleware onRequest hooks for OPTIONS requests
+      for (const plugin of this.middleware) {
+        if (plugin.onRequest) {
+          const result = await plugin.onRequest(ctx);
+          // If middleware returns a response, return it immediately
+          if (result instanceof Response) {
+            return result;
+          }
+        }
+      }
+
+      // Run global onRequest hook
+      if (this.hooks.onRequest) {
+        const result = await this.hooks.onRequest(ctx, this);
+        if (result instanceof Response) {
+          return result;
+        }
+      }
+
+      // Run BXO instance onRequest hooks
+      for (const bxoInstance of this.plugins) {
+        if (bxoInstance.hooks.onRequest) {
+          const result = await bxoInstance.hooks.onRequest(ctx, this);
+          if (result instanceof Response) {
+            return result;
+          }
+        }
+      }
+
+      // If no middleware handled the OPTIONS request, return a default response
+      return new Response(null, {
+        status: 204,
+        headers: ctx.set.headers || {}
+      });
+    }
+
     const matchResult = this.matchRoute(method, pathname);
     if (!matchResult) {
       return new Response('Not Found', { status: 404 });

package/package.json

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

package/plugins/cors.ts

@@ -64,7 +64,7 @@ export function cors(options: CORSOptions = {}): Plugin {
       if (ctx.request.method === 'OPTIONS') {
         const requestOrigin = getRequestOrigin(ctx.request);
         const allowedOrigin = validateOrigin(requestOrigin, origin);
-        
+
         // Set CORS headers for preflight
         ctx.set.headers = {
           ...ctx.set.headers,
@@ -73,39 +73,43 @@ export function cors(options: CORSOptions = {}): Plugin {
           'Access-Control-Allow-Headers': allowedHeaders.join(', '),
           'Access-Control-Max-Age': maxAge.toString()
         };
-        
+
         if (credentials) {
           ctx.set.headers['Access-Control-Allow-Credentials'] = 'true';
         }
+
+        console.log('ctx.set.headers', ctx.set.headers);
+
+        // Return a proper Response for OPTIONS requests
+        return new Response(null, {
+          status: 204,
+          headers: ctx.set.headers
+        });
       }
     },
     onResponse: async (ctx, response) => {
       // Handle CORS headers for actual requests
-      if (response instanceof Response) {
-        const requestOrigin = getRequestOrigin(ctx.request);
-        const allowedOrigin = validateOrigin(requestOrigin, origin);
-        
-        // Clone the response to modify headers
-        const newResponse = new Response(response.body, {
-          status: response.status,
-          statusText: response.statusText,
-          headers: new Headers(response.headers)
-        });
-        
-        // Set CORS headers
-        newResponse.headers.set('Access-Control-Allow-Origin', allowedOrigin || '*');
-        newResponse.headers.set('Access-Control-Allow-Methods', methods.join(', '));
-        newResponse.headers.set('Access-Control-Allow-Headers', allowedHeaders.join(', '));
-        newResponse.headers.set('Access-Control-Max-Age', maxAge.toString());
-        
-        if (credentials) {
-          newResponse.headers.set('Access-Control-Allow-Credentials', 'true');
-        }
-        
-        return newResponse;
+      const requestOrigin = getRequestOrigin(ctx.request);
+      const allowedOrigin = validateOrigin(requestOrigin, origin);
+
+      // Clone the response to modify headers
+      const newResponse = new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: new Headers(response.headers)
+      });
+
+      // Set CORS headers
+      newResponse.headers.set('Access-Control-Allow-Origin', allowedOrigin || '*');
+      newResponse.headers.set('Access-Control-Allow-Methods', methods.join(', '));
+      newResponse.headers.set('Access-Control-Allow-Headers', allowedHeaders.join(', '));
+      newResponse.headers.set('Access-Control-Max-Age', maxAge.toString());
+
+      if (credentials) {
+        newResponse.headers.set('Access-Control-Allow-Credentials', 'true');
       }
-      
-      return response;
+
+      return newResponse;
     }
   };
 }

package/plugins/example.ts

@@ -1,173 +0,0 @@
-import type { Plugin } from '../index';
-
-// Example 1: Simple logging plugin
-export function logger(): Plugin {
-  return {
-    name: 'logger',
-    onRequest: async (ctx) => {
-      console.log(`[${new Date().toISOString()}] ${ctx.request.method} ${ctx.path}`);
-    },
-    onResponse: async (ctx, response) => {
-      if (response instanceof Response) {
-        console.log(`[${new Date().toISOString()}] ${ctx.request.method} ${ctx.path} - ${response.status}`);
-      }
-      return response;
-    },
-    onError: async (ctx, error) => {
-      console.error(`[${new Date().toISOString()}] Error in ${ctx.request.method} ${ctx.path}:`, error);
-    }
-  };
-}
-
-// Example 2: Authentication plugin
-export function auth(secret: string): Plugin {
-  return {
-    name: 'auth',
-    onRequest: async (ctx) => {
-      const token = ctx.headers.authorization?.replace('Bearer ', '');
-      
-      if (!token) {
-        throw new Response(JSON.stringify({ error: 'No token provided' }), {
-          status: 401,
-          headers: { 'Content-Type': 'application/json' }
-        });
-      }
-      
-      // Simple token validation (replace with your actual logic)
-      if (token !== secret) {
-        throw new Response(JSON.stringify({ error: 'Invalid token' }), {
-          status: 401,
-          headers: { 'Content-Type': 'application/json' }
-        });
-      }
-      
-      // Add user info to context
-      (ctx as any).user = { id: 'user-123', token };
-    }
-  };
-}
-
-// Example 3: Request timing plugin
-export function timing(): Plugin {
-  return {
-    name: 'timing',
-    onRequest: async (ctx) => {
-      (ctx as any).startTime = Date.now();
-    },
-    onResponse: async (ctx, response) => {
-      const startTime = (ctx as any).startTime;
-      if (startTime) {
-        const duration = Date.now() - startTime;
-        console.log(`Request to ${ctx.path} took ${duration}ms`);
-        
-        // Add timing header to response
-        if (response instanceof Response) {
-          const newResponse = new Response(response.body, {
-            status: response.status,
-            statusText: response.statusText,
-            headers: new Headers(response.headers)
-          });
-          newResponse.headers.set('X-Response-Time', `${duration}ms`);
-          return newResponse;
-        }
-      }
-      return response;
-    }
-  };
-}
-
-// Example 4: Request ID plugin
-export function requestId(): Plugin {
-  return {
-    name: 'requestId',
-    onRequest: async (ctx) => {
-      const requestId = crypto.randomUUID();
-      (ctx as any).requestId = requestId;
-      
-      // Add request ID to response headers
-      ctx.set.headers = {
-        ...ctx.set.headers,
-        'X-Request-ID': requestId
-      };
-    }
-  };
-}
-
-// Example 5: Conditional plugin (only applies to certain paths)
-export function conditionalAuth(secret: string, paths: string[]): Plugin {
-  return {
-    name: 'conditionalAuth',
-    onRequest: async (ctx) => {
-      // Only apply auth to specified paths
-      if (!paths.some(path => ctx.path.startsWith(path))) {
-        return; // Skip authentication for this path
-      }
-      
-      const token = ctx.headers.authorization?.replace('Bearer ', '');
-      
-      if (!token || token !== secret) {
-        throw new Response(JSON.stringify({ error: 'Authentication required' }), {
-          status: 401,
-          headers: { 'Content-Type': 'application/json' }
-        });
-      }
-    }
-  };
-}
-
-// Example 6: Response transformation plugin
-export function responseTransformer(): Plugin {
-  return {
-    name: 'responseTransformer',
-    onResponse: async (ctx, response) => {
-      // Only transform JSON responses
-      if (response instanceof Response) {
-        const contentType = response.headers.get('content-type');
-        if (contentType?.includes('application/json')) {
-          try {
-            const data = await response.json();
-            
-            // Transform the response data
-            const transformed = {
-              success: true,
-              data,
-              timestamp: new Date().toISOString(),
-              path: ctx.path
-            };
-            
-            return new Response(JSON.stringify(transformed), {
-              status: response.status,
-              headers: response.headers
-            });
-          } catch (error) {
-            // If response is not JSON, return as-is
-            return response;
-          }
-        }
-      }
-      
-      return response;
-    }
-  };
-}
-
-// Example 7: Error handling plugin
-export function errorHandler(): Plugin {
-  return {
-    name: 'errorHandler',
-    onError: async (ctx, error) => {
-      console.error(`Error in ${ctx.request.method} ${ctx.path}:`, error);
-      
-      // Return a standardized error response
-      return new Response(JSON.stringify({
-        error: 'Internal Server Error',
-        message: error.message,
-        timestamp: new Date().toISOString(),
-        path: ctx.path
-      }), {
-        status: 500,
-        headers: { 'Content-Type': 'application/json' }
-      });
-    }
-  };
-}