bxo 0.0.5-dev.54 → 0.0.5-dev.56

package/package.json

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

package/src/utils/index.ts

@@ -78,6 +78,120 @@ 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)) {
+        // Ensure array is large enough
+        while (current.length <= index) {
+          current.push(undefined);
+        }
+        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');
@@ -94,12 +208,47 @@ export async function parseRequestBody(request: Request): Promise<any> {
     const formBody: Record<string, any> = {};
     
     for (const [key, value] of formData.entries()) {
-      if (value instanceof File) {
-        // Return File instances directly
-        formBody[key] = value;
+      // 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
-        formBody[key] = value;
+        // 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;
+        }
       }
     }
     

package/src/utils/response-handler.ts

@@ -134,6 +134,40 @@ export function processResponse(
       });
     }
 
+    // Check if response contains File objects
+    const containsFiles = (obj: any): boolean => {
+      if (obj instanceof File) return true;
+      if (Array.isArray(obj)) {
+        return obj.some(item => containsFiles(item));
+      }
+      if (obj && typeof obj === 'object') {
+        return Object.values(obj).some(value => containsFiles(value));
+      }
+      return false;
+    };
+
+    if (containsFiles(response)) {
+      // For responses containing files, we need to handle them specially
+      // For now, we'll convert File objects to a serializable format
+      const serializableResponse = JSON.parse(JSON.stringify(response, (key, value) => {
+        if (value instanceof File) {
+          return {
+            type: 'File',
+            name: value.name,
+            size: value.size,
+            lastModified: value.lastModified
+          };
+        }
+        return value;
+      }));
+      
+      headers.set('Content-Type', 'application/json');
+      return new Response(JSON.stringify(serializableResponse), {
+        status: ctx.set.status || 200,
+        headers: headers
+      });
+    }
+
     headers.set('Content-Type', 'application/json');
     return new Response(JSON.stringify(response), {
       status: ctx.set.status || 200,
@@ -157,6 +191,42 @@ export function processResponse(
     });
   }
 
+  // Check if response contains File objects (for the no-cookies case)
+  const containsFiles = (obj: any): boolean => {
+    if (obj instanceof File) return true;
+    if (Array.isArray(obj)) {
+      return obj.some(item => containsFiles(item));
+    }
+    if (obj && typeof obj === 'object') {
+      return Object.values(obj).some(value => containsFiles(value));
+    }
+    return false;
+  };
+
+  if (containsFiles(response)) {
+    // For responses containing files, we need to handle them specially
+    // For now, we'll convert File objects to a serializable format
+    const serializableResponse = JSON.parse(JSON.stringify(response, (key, value) => {
+      if (value instanceof File) {
+        return {
+          type: 'File',
+          name: value.name,
+          size: value.size,
+          lastModified: value.lastModified
+        };
+      }
+      return value;
+    }));
+    
+    return new Response(JSON.stringify(serializableResponse), {
+      ...responseInit,
+      headers: {
+        'Content-Type': 'application/json',
+        ...responseInit.headers
+      }
+    });
+  }
+
   return new Response(JSON.stringify(response), {
     ...responseInit,
     headers: {

package/tests/integration/bxo.test.ts

@@ -196,6 +196,191 @@ 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');
+    });
+
+    it('should handle form data with nested arrays and files', async () => {
+      app.post('/api/records-with-files', (ctx) => {
+        return { formData: ctx.body, message: 'Records with files submitted' };
+      });
+
+      const formData = new FormData();
+      formData.append('records[0][qrPayment]', new File(['test file content'], 'test.png', { type: 'image/png' }));
+      formData.append('records[1][qrPayment]', new File(['test file content 2'], 'test2.png', { type: 'image/png' }));
+      formData.append('records[0][name]', 'Record 1');
+      formData.append('records[1][name]', 'Record 2');
+
+      const response = await fetch(`${baseUrl}/api/records-with-files`, {
+        method: 'POST',
+        body: formData
+      });
+
+      const data = await response.json() as { 
+        formData: { 
+          records: Array<{
+            qrPayment: {
+              type: string;
+              name: string;
+              size: number;
+              lastModified: number;
+            },
+            name: string
+          }>
+        }, 
+        message: string 
+      };
+
+      expect(response.status).toBe(200);
+      expect(Array.isArray(data.formData.records)).toBe(true);
+      expect(data.formData.records).toHaveLength(2);
+      expect(data.formData.records[0]?.name).toBe('Record 1');
+      expect(data.formData.records[1]?.name).toBe('Record 2');
+      expect(data.formData.records[0]?.qrPayment).toEqual({
+        type: 'File',
+        name: 'test.png',
+        size: 17,
+        lastModified: 0
+      });
+      expect(data.formData.records[1]?.qrPayment).toEqual({
+        type: 'File',
+        name: 'test2.png',
+        size: 19,
+        lastModified: 0
+      });
+      expect(data.message).toBe('Records with files submitted');
+    });
+
+    it('should have File objects in ctx.body', async () => {
+      app.post('/api/files-test', (ctx) => {
+        // Check if the files are actual File instances
+        const body = ctx.body as {
+          records: Array<{
+            qrPayment: File;
+            name: string;
+          }>;
+        };
+        const records = body.records;
+        console.log('File instance check:');
+        console.log('records[0].qrPayment instanceof File:', records[0]?.qrPayment instanceof File);
+        console.log('records[1].qrPayment instanceof File:', records[1]?.qrPayment instanceof File);
+        console.log('File name:', records[0]?.qrPayment.name);
+        console.log('File size:', records[0]?.qrPayment.size);
+        console.log('File type:', records[0]?.qrPayment.type);
+        
+        return { 
+          message: 'Files received',
+          fileInfo: {
+            isFile0: records[0]?.qrPayment instanceof File,
+            isFile1: records[1]?.qrPayment instanceof File,
+            name0: records[0]?.qrPayment.name,
+            size0: records[0]?.qrPayment.size,
+            type0: records[0]?.qrPayment.type
+          }
+        };
+      });
+
+      const formData = new FormData();
+      formData.append('records[0][qrPayment]', new File(['test file content'], 'test.png', { type: 'image/png' }));
+      formData.append('records[1][qrPayment]', new File(['test file content 2'], 'test2.png', { type: 'image/png' }));
+      formData.append('records[0][name]', 'Record 1');
+      formData.append('records[1][name]', 'Record 2');
+
+      const response = await fetch(`${baseUrl}/api/files-test`, {
+        method: 'POST',
+        body: formData
+      });
+
+      const data = await response.json() as {
+        message: string;
+        fileInfo: {
+          isFile0: boolean;
+          isFile1: boolean;
+          name0: string;
+          size0: number;
+          type0: string;
+        };
+      };
+
+      expect(response.status).toBe(200);
+      expect(data.fileInfo.isFile0).toBe(true);
+      expect(data.fileInfo.isFile1).toBe(true);
+      expect(data.fileInfo.name0).toBe('test.png');
+      expect(data.fileInfo.size0).toBe(17);
+      expect(data.fileInfo.type0).toBe('image/png');
+    });
   });
 
   describe('Response Handling', () => {

package/tests/unit/utils.test.ts

@@ -5,6 +5,7 @@ import {
   parseCookies,
   validateData,
   validateResponse,
+  parseRequestBody,
   cookiesToHeaders,
   mergeHeadersWithCookies,
   createRedirectResponse,
@@ -200,6 +201,165 @@ 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 file = new File(['test'], 'test.jpg', { type: 'image/jpeg' });