bxo 0.0.5-dev.52 → 0.0.5-dev.54

package/package.json

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

package/src/core/bxo.ts

@@ -80,6 +80,7 @@ export default class BXO {
       // It's a middleware plugin
       this.middleware.push(plugin);
     }
+    this.updateRequestHandler();
     return this;
   }
 
@@ -189,8 +190,8 @@ export default class BXO {
   // Update the request handler with current routes and configuration
   private updateRequestHandler(): void {
     this.requestHandler = new RequestHandler(
-      this._routes,
-      this._wsRoutes,
+      this.getAllRoutes(),
+      this.getAllWSRoutes(),
       this.plugins,
       this.middleware,
       this.hooks,

package/src/utils/index.ts

@@ -90,22 +90,13 @@ export async function parseRequestBody(request: Request): Promise<any> {
     }
   } else if (contentType?.includes('multipart/form-data') || contentType?.includes('application/x-www-form-urlencoded')) {
     const formData = await request.formData();
-    // Convert FormData to a structured object that preserves file information
+    // Convert FormData to a structured object
     const formBody: Record<string, any> = {};
     
     for (const [key, value] of formData.entries()) {
       if (value instanceof File) {
-        // Handle file uploads
-        formBody[key] = {
-          type: 'file',
-          name: value.name,
-          size: value.size,
-          lastModified: value.lastModified,
-          file: value, // Keep the actual File object for access
-          // Add convenience properties
-          filename: value.name,
-          mimetype: value.type || 'application/octet-stream'
-        };
+        // Return File instances directly
+        formBody[key] = value;
       } else {
         // Handle regular form fields
         formBody[key] = value;
@@ -186,21 +177,13 @@ export function createRedirectResponse(
 }
 
 // Check if a value is a file upload
-export function isFileUpload(value: any): value is {
-  type: 'file';
-  file: File;
-  name: string;
-  size: number;
-  lastModified: number;
-  filename: string;
-  mimetype: string;
-} {
-  return value && typeof value === 'object' && value.type === 'file' && value.file instanceof File;
+export function isFileUpload(value: any): value is File {
+  return value instanceof File;
 }
 
 // Extract File object from upload value
 export function getFileFromUpload(value: any): File | null {
-  return isFileUpload(value) ? value.file : null;
+  return isFileUpload(value) ? value : null;
 }
 
 // Get file metadata without the File object
@@ -209,7 +192,7 @@ export function getFileInfo(value: any): { name: string; size: number; mimetype:
     return {
       name: value.name,
       size: value.size,
-      mimetype: value.mimetype,
+      mimetype: value.type || 'application/octet-stream',
       lastModified: value.lastModified
     };
   }
@@ -240,7 +223,7 @@ export function getFileUploads(formData: Record<string, any>): Record<string, Fi
   const files: Record<string, File> = {};
   for (const [key, value] of Object.entries(formData)) {
     if (isFileUpload(value)) {
-      files[key] = value.file;
+      files[key] = value;
     }
   }
   return files;

package/tests/unit/utils.test.ts

@@ -202,34 +202,17 @@ describe('Utility Functions', () => {
 
   describe('File Upload Utilities', () => {
     it('should identify file uploads correctly', () => {
-      const fileUpload = {
-        type: 'file',
-        name: 'test.jpg',
-        size: 1024,
-        lastModified: 1234567890,
-        file: new File(['test'], 'test.jpg'),
-        filename: 'test.jpg',
-        mimetype: 'image/jpeg'
-      };
+      const file = new File(['test'], 'test.jpg', { type: 'image/jpeg' });
       
-      expect(isFileUpload(fileUpload)).toBe(true);
+      expect(isFileUpload(file)).toBe(true);
       expect(isFileUpload('not a file')).toBe(false);
       expect(isFileUpload({ type: 'text' })).toBe(false);
     });
 
     it('should extract file from upload', () => {
-      const file = new File(['test'], 'test.jpg');
-      const fileUpload = {
-        type: 'file',
-        name: 'test.jpg',
-        size: 1024,
-        lastModified: 1234567890,
-        file,
-        filename: 'test.jpg',
-        mimetype: 'image/jpeg'
-      };
+      const file = new File(['test'], 'test.jpg', { type: 'image/jpeg' });
       
-      const result = getFileFromUpload(fileUpload);
+      const result = getFileFromUpload(file);
       expect(result).toBe(file);
     });
 
@@ -239,22 +222,14 @@ describe('Utility Functions', () => {
     });
 
     it('should get file info', () => {
-      const fileUpload = {
-        type: 'file',
-        name: 'test.jpg',
-        size: 1024,
-        lastModified: 1234567890,
-        file: new File(['test'], 'test.jpg'),
-        filename: 'test.jpg',
-        mimetype: 'image/jpeg'
-      };
+      const file = new File(['test'], 'test.jpg', { type: 'image/jpeg' });
       
-      const result = getFileInfo(fileUpload);
+      const result = getFileInfo(file);
       expect(result).toEqual({
         name: 'test.jpg',
-        size: 1024,
+        size: 4,
         mimetype: 'image/jpeg',
-        lastModified: 1234567890
+        lastModified: expect.any(Number)
       });
     });
 
@@ -264,17 +239,10 @@ describe('Utility Functions', () => {
     });
 
     it('should get all file uploads from form data', () => {
+      const file = new File(['test'], 'avatar.jpg', { type: 'image/jpeg' });
       const formData = {
         name: 'john',
-        avatar: {
-          type: 'file',
-          name: 'avatar.jpg',
-          size: 1024,
-          lastModified: 1234567890,
-          file: new File(['test'], 'avatar.jpg'),
-          filename: 'avatar.jpg',
-          mimetype: 'image/jpeg'
-        },
+        avatar: file,
         email: 'john@example.com'
       };
       
@@ -285,17 +253,10 @@ describe('Utility Functions', () => {
     });
 
     it('should get all non-file fields from form data', () => {
+      const file = new File(['test'], 'avatar.jpg', { type: 'image/jpeg' });
       const formData = {
         name: 'john',
-        avatar: {
-          type: 'file',
-          name: 'avatar.jpg',
-          size: 1024,
-          lastModified: 1234567890,
-          file: new File(['test'], 'avatar.jpg'),
-          filename: 'avatar.jpg',
-          mimetype: 'image/jpeg'
-        },
+        avatar: file,
         email: 'john@example.com'
       };
       

package/REFACTOR_README.md

@@ -1,209 +0,0 @@
-# BXO Framework - Refactored Structure
-
-The BXO framework has been completely refactored to be more modular, maintainable, and easier to understand. The functionality remains exactly the same, but the code is now organized into logical modules.
-
-## 🏗️ New Directory Structure
-
-```
-src/
-├── core/           # Core BXO class and main logic
-├── types/          # TypeScript type definitions
-├── utils/          # Utility functions and helpers
-├── handlers/       # Request handling logic
-├── plugins/        # Plugin system (existing)
-├── middleware/     # Middleware system (existing)
-└── index.ts        # Main export file
-```
-
-## 📁 Module Breakdown
-
-### `src/types/index.ts`
-- All TypeScript interfaces and types
-- Zod schema type utilities
-- Context, Route, and Plugin interfaces
-- File upload type definitions
-
-### `src/utils/index.ts`
-- Core utility functions for parsing requests
-- Validation helpers
-- Cookie handling utilities
-- File upload utilities
-
-### `src/utils/route-matcher.ts`
-- Route matching logic for HTTP routes
-- WebSocket route matching
-- Wildcard and parameter handling
-
-### `src/utils/context-factory.ts`
-- Context object creation
-- Validation integration
-- Cookie management
-
-### `src/utils/response-handler.ts`
-- Response processing and formatting
-- Error response creation
-- File and Bun.file handling
-
-### `src/utils/helpers.ts`
-- Helper functions (error, file, redirect)
-- Cookie options utilities
-
-### `src/handlers/request-handler.ts`
-- Main request processing logic
-- Middleware and hook execution
-- WebSocket upgrade handling
-- Error handling
-
-### `src/core/bxo.ts`
-- Main BXO class
-- Route registration methods
-- Server lifecycle management
-- Plugin system integration
-
-## 🔄 Migration Guide
-
-### Before (Old Structure)
-```typescript
-import BXO from './index';
-
-const app = new BXO();
-app.get('/', () => 'Hello World');
-```
-
-### After (New Structure)
-```typescript
-import BXO from './index'; // Still works exactly the same!
-
-const app = new BXO();
-app.get('/', () => 'Hello World');
-```
-
-**No changes needed in your existing code!** The API is completely backward compatible.
-
-## ✨ Benefits of Refactoring
-
-### 1. **Better Separation of Concerns**
-- Each module has a single responsibility
-- Easier to understand what each part does
-- Clear boundaries between different functionalities
-
-### 2. **Improved Maintainability**
-- Smaller, focused files are easier to modify
-- Changes to one feature don't affect others
-- Better testability with isolated modules
-
-### 3. **Enhanced Readability**
-- Code is organized logically
-- Related functionality is grouped together
-- Easier to find specific features
-
-### 4. **Better Type Safety**
-- Types are centralized and well-defined
-- Easier to maintain type consistency
-- Better IntelliSense support
-
-### 5. **Easier Testing**
-- Individual modules can be tested in isolation
-- Mocking is simpler with clear interfaces
-- Unit tests are more focused
-
-## 🧪 Testing the Refactored Structure
-
-Run the test file to verify everything works:
-
-```bash
-bun run test-refactored.ts
-```
-
-## 📚 Usage Examples
-
-### Basic Usage (Unchanged)
-```typescript
-import BXO, { z } from './index';
-
-const app = new BXO();
-
-app.get('/', () => 'Hello World');
-
-app.post('/users', async (ctx) => {
-  return { message: 'User created' };
-}, {
-  body: z.object({
-    name: z.string(),
-    email: z.string().email()
-  })
-});
-
-app.start(3000);
-```
-
-### File Uploads (Unchanged)
-```typescript
-import { isFileUpload, saveUploadedFile } from './index';
-
-app.post('/upload', async (ctx) => {
-  if (ctx.body.avatar && isFileUpload(ctx.body.avatar)) {
-    await saveUploadedFile(ctx.body.avatar, './uploads/avatar.jpg');
-  }
-  return { message: 'Upload successful' };
-});
-```
-
-### WebSockets (Unchanged)
-```typescript
-app.ws('/chat', {
-  onOpen: (ws) => console.log('Connected'),
-  onMessage: (ws, message) => ws.send(`Echo: ${message}`)
-});
-```
-
-## 🔧 Development
-
-### Adding New Features
-1. **New utility functions**: Add to `src/utils/`
-2. **New types**: Add to `src/types/`
-3. **New handlers**: Add to `src/handlers/`
-4. **New core features**: Add to `src/core/`
-
-### Modifying Existing Features
-- **Route matching**: Edit `src/utils/route-matcher.ts`
-- **Request parsing**: Edit `src/utils/index.ts`
-- **Response handling**: Edit `src/utils/response-handler.ts`
-- **Context creation**: Edit `src/utils/context-factory.ts`
-
-## 📦 Build and Distribution
-
-The main `index.ts` file now simply re-exports everything from the new structure:
-
-```typescript
-// Re-export everything from the refactored source
-export * from './src/index';
-```
-
-This means:
-- ✅ **Zero breaking changes** for existing users
-- ✅ **Same import syntax** as before
-- ✅ **All functionality preserved**
-- ✅ **Better internal organization**
-
-## 🎯 Future Improvements
-
-With this new structure, we can now easily:
-
-1. **Add new modules** without cluttering the main file
-2. **Implement better testing** with isolated components
-3. **Add new features** in dedicated modules
-4. **Improve performance** by optimizing specific modules
-5. **Better documentation** with focused module descriptions
-
-## 🤝 Contributing
-
-When contributing to the framework:
-
-1. **Identify the right module** for your changes
-2. **Keep modules focused** on their specific responsibility
-3. **Update types** if adding new interfaces
-4. **Add tests** for new functionality
-5. **Update documentation** for new features
-
-The refactored structure makes it much easier to contribute and maintain the codebase!