bxo 0.0.5-dev.53 → 0.0.5-dev.55

package/package.json

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

package/src/utils/index.ts

@@ -78,6 +78,116 @@ export function validateResponse(
   return data;
 }
 
+// Helper function to parse form keys with nested object and array notation (Axios-compatible)
+function parseFormKey(key: string): { 
+  baseKey: string; 
+  path: string[]; 
+  isArray: boolean; 
+  isJson: boolean;
+  hasIndexes: boolean;
+} {
+  // Check for special endings like "{}" for JSON serialization FIRST
+  if (key.endsWith('{}')) {
+    const actualBaseKey = key.slice(0, -2);
+    return { baseKey: actualBaseKey, path: [], isArray: false, isJson: true, hasIndexes: false };
+  }
+  
+  const bracketMatch = key.match(/^([^\[]+)(\[.*\])*$/);
+  if (!bracketMatch) {
+    return { baseKey: key, path: [], isArray: false, isJson: false, hasIndexes: false };
+  }
+  
+  const baseKey = bracketMatch[1];
+  if (!baseKey) {
+    return { baseKey: key, path: [], isArray: false, isJson: false, hasIndexes: false };
+  }
+  
+  const bracketPart = key.slice(baseKey.length);
+  
+  if (!bracketPart) {
+    return { baseKey, path: [], isArray: false, isJson: false, hasIndexes: false };
+  }
+  
+  // Check for special endings like "{}" for JSON serialization
+  if (baseKey.endsWith('{}')) {
+    const actualBaseKey = baseKey.slice(0, -2);
+    return { baseKey: actualBaseKey, path: [], isArray: false, isJson: true, hasIndexes: false };
+  }
+  
+  // If no bracket part, return simple key
+  if (!bracketPart) {
+    return { baseKey, path: [], isArray: false, isJson: false, hasIndexes: false };
+  }
+  
+  // Check if this is an array notation (e.g., "recordIds[]")
+  if (bracketPart === '[]') {
+    return { baseKey, path: [], isArray: true, isJson: false, hasIndexes: false };
+  }
+  
+  // Extract all bracket contents
+  const path: string[] = [];
+  const bracketRegex = /\[([^\]]*)\]/g;
+  let match;
+  let hasIndexes = false;
+  
+  while ((match = bracketRegex.exec(bracketPart)) !== null) {
+    if (match[1] !== undefined) {
+      path.push(match[1]);
+      // Check if this is a numeric index
+      if (/^\d+$/.test(match[1])) {
+        hasIndexes = true;
+      }
+    }
+  }
+  
+  // Check if the last path element is empty (indicating array without indexes)
+  const isArray = path.length > 0 && path[path.length - 1] === '';
+  
+  return { baseKey, path, isArray, isJson: false, hasIndexes };
+}
+
+// Helper function to set nested value in object (Axios-compatible)
+function setNestedValue(obj: any, baseKey: string, path: string[], value: any, isArray: boolean = false): void {
+  if (!(baseKey in obj)) {
+    obj[baseKey] = isArray ? [] : {};
+  }
+  
+  let current = obj[baseKey];
+  
+  // Navigate to the parent of the target location
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (key && (!(key in current) || typeof current[key] !== 'object')) {
+      // Check if next key is numeric (array index)
+      const nextKey = path[i + 1];
+      const isNextKeyNumeric = nextKey && /^\d+$/.test(nextKey);
+      current[key] = isNextKeyNumeric ? [] : {};
+    }
+    if (key) {
+      current = current[key];
+    }
+  }
+  
+  // Set the final value
+  const lastKey = path[path.length - 1];
+  if (lastKey) {
+    if (/^\d+$/.test(lastKey)) {
+      // Numeric key - treat as array index
+      const index = parseInt(lastKey, 10);
+      if (Array.isArray(current)) {
+        current[index] = value;
+      } else {
+        // Convert to array if needed
+        const newArray = [];
+        newArray[index] = value;
+        current[lastKey] = newArray;
+      }
+    } else {
+      current[lastKey] = value;
+    }
+  }
+}
+
 // Parse request body based on content type
 export async function parseRequestBody(request: Request): Promise<any> {
   const contentType = request.headers.get('content-type');
@@ -90,25 +200,56 @@ 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'
-        };
-      } else {
-        // Handle regular form fields
+        // Return File instances directly
         formBody[key] = value;
+      } else {
+        // Parse the key to handle nested objects and arrays (Axios-compatible)
+        const parsedKey = parseFormKey(key);
+        
+        if (parsedKey.isJson) {
+          // Handle JSON serialization (e.g., "obj{}")
+          if (typeof value === 'string') {
+            try {
+              formBody[parsedKey.baseKey] = JSON.parse(value);
+            } catch {
+              formBody[parsedKey.baseKey] = value;
+            }
+          } else {
+            formBody[parsedKey.baseKey] = value;
+          }
+        } else if (parsedKey.isArray) {
+          // Handle array notation like "recordIds[]"
+          if (parsedKey.baseKey in formBody) {
+            if (Array.isArray(formBody[parsedKey.baseKey])) {
+              formBody[parsedKey.baseKey].push(value);
+            } else {
+              formBody[parsedKey.baseKey] = [formBody[parsedKey.baseKey], value];
+            }
+          } else {
+            formBody[parsedKey.baseKey] = [value];
+          }
+        } else if (parsedKey.path.length > 0) {
+          // Handle nested object notation like "test[new]", "test[hi][hi]", "arr[0]", "users[0][name]"
+          setNestedValue(formBody, parsedKey.baseKey, parsedKey.path, value, parsedKey.hasIndexes);
+        } else {
+          // Handle regular form fields - check if this key already exists
+          if (key in formBody) {
+            // If key already exists, convert to array or append to existing array
+            if (Array.isArray(formBody[key])) {
+              formBody[key].push(value);
+            } else {
+              formBody[key] = [formBody[key], value];
+            }
+          } else {
+            // First occurrence of this key
+            formBody[key] = value;
+          }
+        }
       }
     }
     
@@ -186,21 +327,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 +342,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 +373,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/integration/bxo.test.ts

@@ -196,6 +196,81 @@ describe('BXO Framework Integration', () => {
       expect(data.formData.email).toBe('john@example.com');
       expect(data.message).toBe('Form submitted');
     });
+
+    it('should handle form data with arrays', async () => {
+      app.post('/api/records', (ctx) => {
+        return { formData: ctx.body, message: 'Records submitted' };
+      });
+
+      const formData = new FormData();
+      formData.append('app', 'zodula');
+      formData.append('model', 'zodula_User');
+      formData.append('recordIds[]', 'asdfasdfdsa');
+      formData.append('recordIds[]', 'jarupak.sri@gmail.com');
+      formData.append('fields', '*');
+
+      const response = await fetch(`${baseUrl}/api/records`, {
+        method: 'POST',
+        body: formData
+      });
+
+      const data = await response.json() as { 
+        formData: { 
+          app: string, 
+          model: string, 
+          recordIds: string[], 
+          fields: string 
+        }, 
+        message: string 
+      };
+
+      expect(response.status).toBe(200);
+      expect(data.formData.app).toBe('zodula');
+      expect(data.formData.model).toBe('zodula_User');
+      expect(Array.isArray(data.formData.recordIds)).toBe(true);
+      expect(data.formData.recordIds).toEqual(['asdfasdfdsa', 'jarupak.sri@gmail.com']);
+      expect(data.formData.fields).toBe('*');
+      expect(data.message).toBe('Records submitted');
+    });
+
+    it('should handle form data with nested objects', async () => {
+      app.post('/api/nested', (ctx) => {
+        return { formData: ctx.body, message: 'Nested data submitted' };
+      });
+
+      const formData = new FormData();
+      formData.append('test[test]', 'test');
+      formData.append('test[new]', 'new');
+      formData.append('test[hi][hi]', 'hi');
+
+      const response = await fetch(`${baseUrl}/api/nested`, {
+        method: 'POST',
+        body: formData
+      });
+
+      const data = await response.json() as { 
+        formData: { 
+          test: {
+            test: string,
+            new: string,
+            hi: {
+              hi: string
+            }
+          }
+        }, 
+        message: string 
+      };
+
+      expect(response.status).toBe(200);
+      expect(data.formData.test).toEqual({
+        test: 'test',
+        new: 'new',
+        hi: {
+          hi: 'hi'
+        }
+      });
+      expect(data.message).toBe('Nested data submitted');
+    });
   });
 
   describe('Response Handling', () => {

package/tests/unit/utils.test.ts

@@ -5,6 +5,7 @@ import {
   parseCookies,
   validateData,
   validateResponse,
+  parseRequestBody,
   cookiesToHeaders,
   mergeHeadersWithCookies,
   createRedirectResponse,
@@ -200,36 +201,178 @@ describe('Utility Functions', () => {
     });
   });
 
+  describe('parseRequestBody', () => {
+    it('should parse JSON body correctly', async () => {
+      const jsonData = { name: 'john', age: 25 };
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(jsonData)
+      });
+
+      const result = await parseRequestBody(request);
+      expect(result).toEqual(jsonData);
+    });
+
+    it('should parse form data with arrays correctly', async () => {
+      const formData = new FormData();
+      formData.append('app', 'zodula');
+      formData.append('model', 'zodula_User');
+      formData.append('recordIds[]', 'asdfasdfdsa');
+      formData.append('recordIds[]', 'jarupak.sri@gmail.com');
+      formData.append('fields', '*');
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+      
+      expect(result.app).toBe('zodula');
+      expect(result.model).toBe('zodula_User');
+      expect(Array.isArray(result.recordIds)).toBe(true);
+      expect(result.recordIds).toEqual(['asdfasdfdsa', 'jarupak.sri@gmail.com']);
+      expect(result.fields).toBe('*');
+    });
+
+    it('should handle single form field correctly', async () => {
+      const formData = new FormData();
+      formData.append('name', 'john');
+      formData.append('email', 'john@example.com');
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+      
+      expect(result.name).toBe('john');
+      expect(result.email).toBe('john@example.com');
+    });
+
+    it('should handle file uploads in form data', async () => {
+      const file = new File(['test content'], 'test.txt', { type: 'text/plain' });
+      const formData = new FormData();
+      formData.append('name', 'john');
+      formData.append('file', file);
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+      
+      expect(result.name).toBe('john');
+      expect(result.file).toBeInstanceOf(File);
+      expect(result.file.name).toBe('test.txt');
+    });
+
+    it('should parse nested object form data correctly', async () => {
+      const formData = new FormData();
+      formData.append('test[test]', 'test');
+      formData.append('test[new]', 'new');
+      formData.append('test[hi][hi]', 'hi');
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+      
+      expect(result.test).toEqual({
+        test: 'test',
+        new: 'new',
+        hi: {
+          hi: 'hi'
+        }
+      });
+    });
+
+    it('should parse Axios-compatible multipart data with arrays and objects', async () => {
+      const formData = new FormData();
+      formData.append('x', '1');
+      formData.append('arr[]', '1');
+      formData.append('arr[]', '2');
+      formData.append('arr[]', '3');
+      formData.append('arr2[0]', '1');
+      formData.append('arr2[1][0]', '2');
+      formData.append('arr2[2]', '3');
+      formData.append('users[0][name]', 'Peter');
+      formData.append('users[0][surname]', 'Griffin');
+      formData.append('users[1][name]', 'Thomas');
+      formData.append('users[1][surname]', 'Anderson');
+      formData.append('obj2{}', '[{"x":1}]');
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+      
+      expect(result.x).toBe('1');
+      expect(result.arr).toEqual(['1', '2', '3']);
+      expect(result.arr2).toEqual(['1', ['2'], '3']);
+      expect(result.users).toEqual([
+        { name: 'Peter', surname: 'Griffin' },
+        { name: 'Thomas', surname: 'Anderson' }
+      ]);
+      expect(result.obj2).toEqual([{ x: 1 }]);
+    });
+
+    it('should handle JSON serialization with special endings', async () => {
+      const formData = new FormData();
+      formData.append('myObj{}', '{"x": 1, "s": "foo"}');
+      formData.append('settings{}', '{"theme": "dark", "notifications": true}');
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+      
+      expect(result.myObj).toEqual({ x: 1, s: 'foo' });
+      expect(result.settings).toEqual({ theme: 'dark', notifications: true });
+    });
+
+    it('should handle mixed array indexing styles', async () => {
+      const formData = new FormData();
+      formData.append('tags[]', 'javascript');
+      formData.append('tags[]', 'typescript');
+      formData.append('scores[0]', '100');
+      formData.append('scores[1]', '95');
+      formData.append('scores[2]', '88');
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+      
+      expect(result.tags).toEqual(['javascript', 'typescript']);
+      expect(result.scores).toEqual(['100', '95', '88']);
+    });
+  });
+
   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 +382,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 +399,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 +413,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'
       };