bxo 0.0.5-dev.2 → 0.0.5-dev.21

package/package.json

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

package/plugins/index.ts

@@ -1,7 +1,5 @@
 // Export all plugins
 export { cors } from './cors';
-export { logger } from './logger';
-export { auth, createJWT } from './auth';
 export { rateLimit } from './ratelimit';
 
 // Import BXO for plugin typing

package/example.ts

@@ -1,183 +0,0 @@
-import BXO, { z } from './index';
-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({ 
-    origin: ['http://localhost:3000', 'https://example.com'],
-    credentials: true 
-  }))
-  .use(rateLimit({ 
-    max: 100, 
-    window: 60, // 1 minute
-    exclude: ['/health'] 
-  }))
-  .use(auth({ 
-    type: 'jwt', 
-    secret: 'your-secret-key',
-    exclude: ['/', '/login', '/health']
-  }));
-
-// Add simplified lifecycle hooks
-app
-  .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...');
-  })
-  .onAfterRestart(() => {
-    console.log('✅ Server restart completed!');
-  })
-  .onRequest((ctx) => {
-    console.log(`📨 Processing ${ctx.request.method} ${ctx.request.url}`);
-  })
-  .onResponse((ctx, response) => {
-    console.log(`📤 Response sent for ${ctx.request.method} ${ctx.request.url}`);
-    return response;
-  })
-  .onError((ctx, error) => {
-    console.error(`💥 Error in ${ctx.request.method} ${ctx.request.url}:`, error.message);
-    return { error: 'Something went wrong', timestamp: new Date().toISOString() };
-  });
-
-// Routes exactly like your example
-app
-  // Two arguments: path, handler
-  .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)
-    // ctx.query.include is typed as string | undefined
-    return { user: { id: ctx.params.id, include: ctx.query.include } };
-  }, {
-    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 };
-  }, {
-    body: z.object({
-      name: z.string(),
-      email: z.string().email()
-    })
-  })
-
-  // Additional examples
-  .get('/health', async (ctx) => {
-    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' };
-  }, {
-    body: z.object({
-      username: z.string(),
-      password: z.string()
-    })
-  })
-
-  .get('/protected', async (ctx) => {
-    // ctx.user is available here because of auth plugin
-    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(),
-      uptime: process.uptime(),
-      memory: process.memoryUsage()
-    };
-  })
-
-  .put('/users/:id', async (ctx) => {
-    return { 
-      updated: ctx.body, 
-      id: ctx.params.id,
-      version: ctx.headers['if-match']
-    };
-  }, {
-    params: z.object({ id: z.string().uuid() }),
-    body: z.object({
-      name: z.string().optional(),
-      email: z.string().email().optional()
-    }),
-    headers: z.object({
-      'if-match': z.string()
-    })
-  })
-
-  .delete('/users/:id', async (ctx) => {
-    ctx.set.status = 204;
-    return null;
-  }, {
-    params: z.object({ id: z.string().uuid() })
-  });
-
-// Start the server (with hot reload enabled)
-app.start(3000, 'localhost');
-
-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
-
-🧪 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 (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/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;
-}