bxo 0.0.5-dev.8 → 0.0.5-dev.81

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;
-} 

package/plugins/ratelimit.ts

@@ -1,140 +0,0 @@
-import BXO from '../index';
-
-interface RateLimitOptions {
-  max: number;
-  window: number; // in seconds
-  keyGenerator?: (ctx: any) => string;
-  skipSuccessful?: boolean;
-  skipFailed?: boolean;
-  exclude?: string[];
-  message?: string;
-  statusCode?: number;
-}
-
-class RateLimitStore {
-  private store = new Map<string, { count: number; resetTime: number }>();
-
-  get(key: string): { count: number; resetTime: number } | undefined {
-    const entry = this.store.get(key);
-    if (entry && Date.now() > entry.resetTime) {
-      this.store.delete(key);
-      return undefined;
-    }
-    return entry;
-  }
-
-  set(key: string, count: number, resetTime: number): void {
-    this.store.set(key, { count, resetTime });
-  }
-
-  increment(key: string, window: number): { count: number; resetTime: number } {
-    const now = Date.now();
-    const entry = this.get(key);
-    
-    if (!entry) {
-      const resetTime = now + (window * 1000);
-      this.set(key, 1, resetTime);
-      return { count: 1, resetTime };
-    }
-    
-    entry.count++;
-    this.set(key, entry.count, entry.resetTime);
-    return entry;
-  }
-
-  cleanup(): void {
-    const now = Date.now();
-    for (const [key, entry] of this.store.entries()) {
-      if (now > entry.resetTime) {
-        this.store.delete(key);
-      }
-    }
-  }
-}
-
-export function rateLimit(options: RateLimitOptions): BXO {
-  const {
-    max,
-    window,
-    keyGenerator = (ctx) => {
-      // Default: use IP address
-      return ctx.request.headers.get('x-forwarded-for') || 
-             ctx.request.headers.get('x-real-ip') || 
-             'unknown';
-    },
-    skipSuccessful = false,
-    skipFailed = false,
-    exclude = [],
-    message = 'Too many requests',
-    statusCode = 429
-  } = options;
-
-  const store = new RateLimitStore();
-  
-  // Cleanup expired entries every 5 minutes
-  setInterval(() => store.cleanup(), 5 * 60 * 1000);
-
-  const rateLimitInstance = new BXO();
-
-  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);
-      }
-      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()
-    };
-  });
-
-  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);
-      }
-    }
-    
-    return response;
-  });
-
-  return rateLimitInstance;
-}