bxo 0.0.5-dev.20 → 0.0.5-dev.22

package/README.md

@@ -20,7 +20,7 @@ BXO is a fast, lightweight, and fully type-safe web framework built specifically
 ### Installation
 
 ```bash
-bun add zod
+bun add bxo
 ```
 
 ### Basic Usage

package/index.ts

@@ -3,6 +3,31 @@ import { z } from 'zod';
 // Type utilities for extracting types from Zod schemas
 type InferZodType<T> = T extends z.ZodType<infer U> ? U : never;
 
+// Response configuration types
+type ResponseSchema = z.ZodSchema<any>;
+type StatusResponseSchema = Record<number, ResponseSchema>;
+type ResponseConfig = ResponseSchema | StatusResponseSchema;
+
+// Type utility to extract response type from response config
+type InferResponseType<T> = T extends ResponseSchema 
+  ? InferZodType<T>
+  : T extends StatusResponseSchema 
+    ? { [K in keyof T]: InferZodType<T[K]> }[keyof T]
+    : never;
+
+// Cookie interface
+interface Cookie {
+  name: string;
+  value: string;
+  domain?: string;
+  path?: string;
+  expires?: Date;
+  maxAge?: number;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: 'Strict' | 'Lax' | 'None';
+}
+
 // OpenAPI detail information
 interface RouteDetail {
   summary?: string;
@@ -21,7 +46,8 @@ interface RouteConfig {
   query?: z.ZodSchema<any>;
   body?: z.ZodSchema<any>;
   headers?: z.ZodSchema<any>;
-  response?: z.ZodSchema<any>;
+  cookies?: z.ZodSchema<any>;
+  response?: ResponseConfig;
   detail?: RouteDetail;
 }
 
@@ -31,17 +57,20 @@ export type Context<TConfig extends RouteConfig = {}> = {
   query: TConfig['query'] extends z.ZodSchema<any> ? InferZodType<TConfig['query']> : Record<string, string | undefined>;
   body: TConfig['body'] extends z.ZodSchema<any> ? InferZodType<TConfig['body']> : unknown;
   headers: TConfig['headers'] extends z.ZodSchema<any> ? InferZodType<TConfig['headers']> : Record<string, string>;
+  cookies: TConfig['cookies'] extends z.ZodSchema<any> ? InferZodType<TConfig['cookies']> : Record<string, string>;
   path: string;
   request: Request;
   set: {
     status?: number;
     headers?: Record<string, string>;
+    cookies?: Cookie[];
   };
+  status: (code: number, data?: any) => any;
   [key: string]: any;
 };
 
-// Handler function type
-type Handler<TConfig extends RouteConfig = {}, EC = {}> = (ctx: Context<TConfig> & EC) => Promise<any> | any;
+// Handler function type with proper response typing
+type Handler<TConfig extends RouteConfig = {}, EC = {}> = (ctx: Context<TConfig> & EC) => Promise<InferResponseType<TConfig['response']> | any> | InferResponseType<TConfig['response']> | any;
 
 // Route definition
 interface Route {
@@ -394,12 +423,61 @@ export default class BXO {
     return headerObj;
   }
 
+  // Parse cookies from Cookie header
+  private parseCookies(cookieHeader: string | null): Record<string, string> {
+    const cookies: Record<string, string> = {};
+    
+    if (!cookieHeader) return cookies;
+    
+    const cookiePairs = cookieHeader.split(';');
+    for (const pair of cookiePairs) {
+      const [name, value] = pair.trim().split('=');
+      if (name && value) {
+        cookies[decodeURIComponent(name)] = decodeURIComponent(value);
+      }
+    }
+    
+    return cookies;
+  }
+
   // Validate data against Zod schema
   private validateData<T>(schema: z.ZodSchema<T> | undefined, data: any): T {
     if (!schema) return data;
     return schema.parse(data);
   }
 
+  // Validate response against response config (supports both simple and status-based schemas)
+  private validateResponse(responseConfig: ResponseConfig | undefined, data: any, status: number = 200): any {
+    if (!responseConfig) return data;
+    
+    // If it's a simple schema (not status-based)
+    if ('parse' in responseConfig && typeof responseConfig.parse === 'function') {
+      return responseConfig.parse(data);
+    }
+    
+    // If it's a status-based schema
+    if (typeof responseConfig === 'object' && !('parse' in responseConfig)) {
+      const statusSchema = responseConfig[status];
+      if (statusSchema) {
+        return statusSchema.parse(data);
+      }
+      
+      // If no specific status schema found, try to find a fallback
+      // Common fallback statuses: 200, 201, 400, 500
+      const fallbackStatuses = [200, 201, 400, 500];
+      for (const fallbackStatus of fallbackStatuses) {
+        if (responseConfig[fallbackStatus]) {
+          return responseConfig[fallbackStatus].parse(data);
+        }
+      }
+      
+      // If no schema found for the status, return data as-is
+      return data;
+    }
+    
+    return data;
+  }
+
   // Main request handler
   private async handleRequest(request: Request, server?: any): Promise<Response | undefined> {
     const url = new URL(request.url);
@@ -433,6 +511,7 @@ export default class BXO {
     const { route, params } = matchResult;
     const query = this.parseQuery(url.searchParams);
     const headers = this.parseHeaders(request.headers);
+    const cookies = this.parseCookies(request.headers.get('cookie'));
 
     let body: any;
     if (request.method !== 'GET' && request.method !== 'HEAD') {
@@ -470,15 +549,21 @@ export default class BXO {
       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;
+      const validatedCookies = route.config?.cookies ? this.validateData(route.config.cookies, cookies) : cookies;
       
       ctx = {
         params: validatedParams,
         query: validatedQuery,
         body: validatedBody,
         headers: validatedHeaders,
+        cookies: validatedCookies,
         path: pathname,
         request,
-        set: {}
+        set: {},
+        status: (code: number, data?: any) => {
+          ctx.set.status = code;
+          return data;
+        }
       };
     } catch (validationError) {
       // Validation failed - return error response
@@ -539,7 +624,8 @@ export default class BXO {
       if (route.config?.response && !(response instanceof Response)) {
         try {
           console.log('response', response);
-          response = this.validateData(route.config.response, response);
+          const status = ctx.set.status || 200;
+          response = this.validateResponse(route.config.response, response, status);
         } catch (validationError) {
           // Response validation failed
           
@@ -602,9 +688,34 @@ export default class BXO {
         return new Response(bunFile, responseInit);
       }
 
+      // Prepare headers with cookies
+      let responseHeaders = ctx.set.headers ? { ...ctx.set.headers } : {};
+      
+      // Handle cookies if any are set
+      if (ctx.set.cookies && ctx.set.cookies.length > 0) {
+        const cookieHeaders = ctx.set.cookies.map(cookie => {
+          let cookieString = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
+          
+          if (cookie.domain) cookieString += `; Domain=${cookie.domain}`;
+          if (cookie.path) cookieString += `; Path=${cookie.path}`;
+          if (cookie.expires) cookieString += `; Expires=${cookie.expires.toUTCString()}`;
+          if (cookie.maxAge) cookieString += `; Max-Age=${cookie.maxAge}`;
+          if (cookie.secure) cookieString += `; Secure`;
+          if (cookie.httpOnly) cookieString += `; HttpOnly`;
+          if (cookie.sameSite) cookieString += `; SameSite=${cookie.sameSite}`;
+          
+          return cookieString;
+        });
+        
+        // Add Set-Cookie headers
+        cookieHeaders.forEach((cookieHeader, index) => {
+          responseHeaders[index === 0 ? 'Set-Cookie' : `Set-Cookie-${index}`] = cookieHeader;
+        });
+      }
+
       const responseInit: ResponseInit = {
         status: ctx.set.status || 200,
-        headers: ctx.set.headers || {}
+        headers: responseHeaders
       };
 
       if (typeof response === 'string') {
@@ -905,4 +1016,15 @@ const file = (path: string, options?: { type?: string; headers?: Record<string,
 export { z, error, file };
 
 // Export types for external use
-export type { RouteConfig, RouteDetail, Handler, WebSocketHandler, WSRoute };
+export type { RouteConfig, RouteDetail, Handler, WebSocketHandler, WSRoute, Cookie };
+
+// Helper function to create a cookie
+export const createCookie = (
+  name: string,
+  value: string,
+  options: Omit<Cookie, 'name' | 'value'> = {}
+): Cookie => ({
+  name,
+  value,
+  ...options
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bxo",
   "module": "index.ts",
-  "version": "0.0.5-dev.20",
+  "version": "0.0.5-dev.22",
   "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,204 +0,0 @@
-import BXO, { z } from './index';
-import { cors, logger, auth, rateLimit, createJWT } from './plugins';
-
-// Create a simple API plugin that defines its own routes
-function createApiPlugin(): BXO {
-  const apiPlugin = new BXO();
-  
-  apiPlugin
-    .get('/api/info', async (ctx) => {
-      return { 
-        name: 'BXO API Plugin',
-        version: '1.0.0',
-        endpoints: ['/api/info', '/api/ping', '/api/time']
-      };
-    })
-    .get('/api/ping', async (ctx) => {
-      return { ping: 'pong', timestamp: Date.now() };
-    })
-    .get('/api/time', async (ctx) => {
-      return { time: new Date().toISOString() };
-    })
-    .post('/api/echo', async (ctx) => {
-      return { echo: ctx.body };
-    }, {
-      body: z.object({
-        message: z.string()
-      })
-    });
-    
-  return apiPlugin;
-}
-
-// Create the app instance
-const app = new BXO();
-
-// Add plugins (including our new API plugin)
-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', '/api/*']
-  }))
-  .use(createApiPlugin()); // Add our plugin with actual routes
-
-// 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!');
-  })
-  .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 };
-  })
-
-  .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:
-- 🎣 Full lifecycle hooks (before/after pattern)
-- 🔒 JWT authentication
-- 📊 Rate limiting  
-- 🌐 CORS support
-- 📝 Request logging
-- 🔌 API Plugin with routes
-
-🧪 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)
-
-🔌 API Plugin endpoints:
-- GET  /api/info (plugin information)
-- GET  /api/ping (ping pong)
-- GET  /api/time (current time)
-- POST /api/echo (echo message: {"message": "hello"})
-
-💡 Edit this file and save to see hot reload in action!
-`); 
-
-console.log(app.routes)