bxo 0.0.5-dev.16 → 0.0.5-dev.18

package/index.ts

@@ -447,20 +447,50 @@ export default class BXO {
         const formData = await request.formData();
         body = Object.fromEntries(formData.entries());
       } else {
-        body = await request.text();
+        // Try to parse as JSON if it looks like JSON, otherwise treat as text
+        const textBody = await request.text();
+        try {
+          // Check if the text looks like JSON
+          if (textBody.trim().startsWith('{') || textBody.trim().startsWith('[')) {
+            body = JSON.parse(textBody);
+          } else {
+            body = textBody;
+          }
+        } catch {
+          body = textBody;
+        }
       }
     }
 
-    // Create context
-    const ctx: Context = {
-      params: route.config?.params ? this.validateData(route.config.params, params) : params,
-      query: route.config?.query ? this.validateData(route.config.query, query) : query,
-      body: route.config?.body ? this.validateData(route.config.body, body) : body,
-      headers: route.config?.headers ? this.validateData(route.config.headers, headers) : headers,
-      path: pathname,
-      request,
-      set: {}
-    };
+    // Create context with validation
+    let ctx: Context;
+    try {
+      // Validate each part separately to get better error messages
+      const validatedParams = route.config?.params ? this.validateData(route.config.params, params) : params;
+      const validatedQuery = route.config?.query ? this.validateData(route.config.query, query) : query;
+      const validatedBody = route.config?.body ? this.validateData(route.config.body, body) : body;
+      const validatedHeaders = route.config?.headers ? this.validateData(route.config.headers, headers) : headers;
+      
+      ctx = {
+        params: validatedParams,
+        query: validatedQuery,
+        body: validatedBody,
+        headers: validatedHeaders,
+        path: pathname,
+        request,
+        set: {}
+      };
+    } catch (validationError) {
+      // Validation failed - return error response
+      const errorMessage = validationError instanceof Error ? validationError.message : 'Validation failed';
+      return new Response(JSON.stringify({ 
+        error: `Validation error: ${errorMessage}`,
+        details: validationError instanceof Error && 'errors' in validationError ? validationError.errors : undefined
+      }), {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
 
     try {
       // Run global onRequest hook
@@ -493,6 +523,7 @@ export default class BXO {
       // Validate response against schema if provided
       if (route.config?.response && !(response instanceof Response)) {
         try {
+          console.log('response', response);
           response = this.validateData(route.config.response, response);
         } catch (validationError) {
           // Response validation failed
@@ -629,6 +660,11 @@ export default class BXO {
         }
       });
 
+      // Verify server was created successfully
+      if (!this.server) {
+        throw new Error('Failed to create server instance');
+      }
+
       this.isRunning = true;
       this.serverPort = port;
       this.serverHostname = hostname;
@@ -666,10 +702,22 @@ export default class BXO {
       }
 
       if (this.server) {
-        this.server.stop();
-        this.server = null;
+        try {
+          // Try to stop the server gracefully
+          if (typeof this.server.stop === 'function') {
+            this.server.stop();
+          } else {
+            console.warn('⚠️  Server stop method not available');
+          }
+        } catch (stopError) {
+          console.error('❌ Error calling server.stop():', stopError);
+        }
+        
+        // Clear the server reference
+        this.server = undefined;
       }
 
+      // Reset state regardless of server.stop() success
       this.isRunning = false;
       this.serverPort = undefined;
       this.serverHostname = undefined;
@@ -679,8 +727,15 @@ export default class BXO {
         await this.hooks.onAfterStop(this);
       }
 
+      console.log('✅ Server stopped successfully');
+
     } catch (error) {
       console.error('❌ Error stopping server:', error);
+      // Even if there's an error, reset the state
+      this.isRunning = false;
+      this.server = undefined;
+      this.serverPort = undefined;
+      this.serverHostname = undefined;
       throw error;
     }
   }
@@ -694,7 +749,7 @@ export default class BXO {
 
   // Server status
   isServerRunning(): boolean {
-    return this.isRunning;
+    return this.isRunning && this.server !== undefined;
   }
 
   getServerInfo(): { running: boolean } {

package/package.json

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

package/plugins/auth.ts

@@ -1,119 +0,0 @@
-import BXO from '../index';
-
-interface AuthOptions {
-  type: 'jwt' | 'bearer' | 'apikey';
-  secret?: string;
-  header?: string;
-  verify?: (token: string, ctx: any) => Promise<any> | any;
-  exclude?: string[];
-}
-
-export function auth(options: AuthOptions): BXO {
-  const {
-    type,
-    secret,
-    header = 'authorization',
-    verify,
-    exclude = []
-  } = options;
-
-  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' }), {
-        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;
-    }
-
-    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 };
-      }
-
-      // 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)
-export function createJWT(payload: any, secret: string, expiresIn: number = 3600): string {
-  const header = { alg: 'HS256', typ: 'JWT' };
-  const now = Math.floor(Date.now() / 1000);
-  
-  const jwtPayload = {
-    ...payload,
-    iat: now,
-    exp: now + expiresIn
-  };
-  
-  const headerB64 = btoa(JSON.stringify(header));
-  const payloadB64 = btoa(JSON.stringify(jwtPayload));
-  
-  // Simple signature (in production, use proper HMAC-SHA256)
-  const signature = btoa(`${headerB64}.${payloadB64}.${secret}`);
-  
-  return `${headerB64}.${payloadB64}.${signature}`;
-} 

package/plugins/logger.ts

@@ -1,109 +0,0 @@
-import BXO from '../index';
-
-interface LoggerOptions {
-  format?: 'simple' | 'detailed' | 'json';
-  includeBody?: boolean;
-  includeHeaders?: boolean;
-}
-
-export function logger(options: LoggerOptions = {}): BXO {
-  const {
-    format = 'simple',
-    includeBody = false,
-    includeHeaders = false
-  } = options;
-
-  const loggerInstance = new BXO();
-
-  loggerInstance.onRequest(async (ctx: any) => {
-    ctx._startTime = Date.now();
-    
-    if (format === 'json') {
-      const logData: any = {
-        timestamp: new Date().toISOString(),
-        method: ctx.request.method,
-        url: ctx.request.url,
-        type: 'request'
-      };
-      
-      if (includeHeaders) {
-        logData.headers = Object.fromEntries(ctx.request.headers.entries());
-      }
-      
-      if (includeBody && ctx.body) {
-        logData.body = ctx.body;
-      }
-      
-      console.log(JSON.stringify(logData));
-    } else if (format === 'detailed') {
-      console.log(`→ ${ctx.request.method} ${ctx.request.url}`);
-      if (includeHeaders) {
-        console.log('  Headers:', Object.fromEntries(ctx.request.headers.entries()));
-      }
-      if (includeBody && ctx.body) {
-        console.log('  Body:', ctx.body);
-      }
-    } else {
-      console.log(`→ ${ctx.request.method} ${ctx.request.url}`);
-    }
-  });
-
-  loggerInstance.onResponse(async (ctx: any, response: any) => {
-    const duration = Date.now() - (ctx._startTime || 0);
-    const status = ctx.set.status || 200;
-    
-    if (format === 'json') {
-      const logData: any = {
-        timestamp: new Date().toISOString(),
-        method: ctx.request.method,
-        url: ctx.request.url,
-        status,
-        duration: `${duration}ms`,
-        type: 'response'
-      };
-      
-      if (includeHeaders && ctx.set.headers) {
-        logData.responseHeaders = ctx.set.headers;
-      }
-      
-      if (includeBody && response) {
-        logData.response = response;
-      }
-      
-      console.log(JSON.stringify(logData));
-    } else if (format === 'detailed') {
-      console.log(`← ${ctx.request.method} ${ctx.request.url} ${status} ${duration}ms`);
-      if (includeHeaders && ctx.set.headers) {
-        console.log('  Response Headers:', ctx.set.headers);
-      }
-      if (includeBody && response) {
-        console.log('  Response:', response);
-      }
-    } else {
-      const statusColor = status >= 400 ? '\x1b[31m' : status >= 300 ? '\x1b[33m' : '\x1b[32m';
-      const resetColor = '\x1b[0m';
-      console.log(`← ${ctx.request.method} ${ctx.request.url} ${statusColor}${status}${resetColor} ${duration}ms`);
-    }
-    
-    return response;
-  });
-
-  loggerInstance.onError(async (ctx: any, error: Error) => {
-    const duration = Date.now() - (ctx._startTime || 0);
-    
-    if (format === 'json') {
-      console.log(JSON.stringify({
-        timestamp: new Date().toISOString(),
-        method: ctx.request.method,
-        url: ctx.request.url,
-        error: error.message,
-        duration: `${duration}ms`,
-        type: 'error'
-      }));
-    } else {
-      console.log(`✗ ${ctx.request.method} ${ctx.request.url} \x1b[31mERROR\x1b[0m ${duration}ms: ${error.message}`);
-    }
-  });
-
-  return loggerInstance;
-}